using Salad.Cloud.SDK;
using Salad.Cloud.SDK.Config;
using Salad.Cloud.SDK.Models;

var config = new SaladCloudSdkConfig{};

var client = new SaladCloudSdkClient(config);

var gpuClasses = new List<string>() { "gpu_classes" };
var resources = new CreateContainerResourceRequirements(827, 734164836, gpuClasses, 64, 761306530849177.9);
var command = new List<string>() { "command" };
var axiom = new AxiomLoggingConfiguration("api_token", "dataset", "host");
var tagsItem = new DatadogTagForContainerLogging("name", "value");
var tags = new List<DatadogTagForContainerLogging>() { tagsItem };
var datadog = new DatadogLoggingConfiguration("api_key", "host", tags);
var headersItem = new ContainerLoggingHttpHeader("name", "value");
var headers = new List<ContainerLoggingHttpHeader>() { headersItem };
var http = new ContainerLoggingConfigurationHttp2(ContainerLoggingHttpCompression.None, ContainerLoggingHttpFormat.Json, "host", 42056, headers, "password", "path", "user");
var newRelic = new NewRelicLoggingConfiguration("host", "ingestion_key");
var splunk = new ContainerLoggingSplunkConfiguration("host", "token");
var tcp = new TcpLoggingConfiguration("host", 44671);
var logging = new ContainerConfigurationLogging(axiom, datadog, http, newRelic, splunk, tcp);
var awsEcr = new ContainerRegistryAuthenticationAwsEcr("access_key_id", "secret_access_key");
var basic = new ContainerRegistryAuthenticationBasic("password", "username");
var dockerHub = new ContainerRegistryAuthenticationDockerHub("personal_access_token", "username");
var gcpGar = new ContainerRegistryAuthenticationGcpGar("service_key");
var gcpGcr = new ContainerRegistryAuthenticationGcpGcr("service_key");
var registryAuthentication = new ContainerRegistryAuthentication(awsEcr, basic, dockerHub, gcpGar, gcpGcr);
var container = new ContainerConfiguration("acme/:latest", resources, command, new object(), true, logging, ContainerGroupPriority.High, registryAuthentication);
var countryCodes = new List<CountryCode>() { CountryCode.Af };
var command = new List<string>() { "command" };
var exec = new ContainerGroupProbeExec(command);
var grpc = new ContainerGroupGRpcProbe(37648, "service");
var headersItem = new ContainerGroupProbeHttpHeader("name", "value");
var headers = new List<ContainerGroupProbeHttpHeader>() { headersItem };
var http = new ContainerGroupHttpProbeConfiguration(headers, "path", 29069, HttpScheme.Http);
var tcp = new ContainerGroupTcpProbe(13817);
var livenessProbe = new ContainerGroupLivenessProbe(3, 670, 10, 1, 30, exec, grpc, http, tcp);
var networking = new CreateContainerGroupNetworking(false, 60000, ContainerNetworkingProtocol.Http, 100000, TheContainerGroupNetworkingLoadBalancer.RoundRobin, 100000, false);
var queueAutoscaler = new QueueBasedAutoscalerConfiguration(53, 321, 54, 59, 100, 140);
var queueConnection = new ContainerGroupQueueConnection("path", 47568, "z1h-3z01x9");
var command = new List<string>() { "command" };
var exec = new ContainerGroupProbeExec(command);
var grpc = new ContainerGroupGRpcProbe(37648, "service");
var headersItem = new ContainerGroupProbeHttpHeader("name", "value");
var headers = new List<ContainerGroupProbeHttpHeader>() { headersItem };
var http = new ContainerGroupHttpProbeConfiguration(headers, "path", 29069, HttpScheme.Http);
var tcp = new ContainerGroupTcpProbe(13817);
var readinessProbe = new ContainerGroupReadinessProbe(3, 262, 1, 1, 1, exec, grpc, http, tcp);
var scalingActionsItem = new ContainerGroupScalingAction(461, "7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT");
var scalingActions = new List<ContainerGroupScalingAction>() { scalingActionsItem };
var command = new List<string>() { "command" };
var exec = new ContainerGroupProbeExec(command);
var grpc = new ContainerGroupGRpcProbe(37648, "service");
var headersItem = new ContainerGroupProbeHttpHeader("name", "value");
var headers = new List<ContainerGroupProbeHttpHeader>() { headersItem };
var http = new ContainerGroupHttpProbeConfiguration(headers, "path", 29069, HttpScheme.Http);
var tcp = new ContainerGroupTcpProbe(13817);
var startupProbe = new ContainerGroupStartupProbe(15, 503, 3, 2, 10, exec, grpc, http, tcp);
var input = new ContainerGroupCreationRequest(false, container, "name", 77, ContainerRestartPolicy.Always, countryCodes, "KMg0KyVwpb", livenessProbe, networking, queueAutoscaler, queueConnection, readinessProbe, scalingActions, true, startupProbe);

var response = await client.ContainerGroups.CreateContainerGroupAsync(input, "acme-corp", "dev-env");

Console.WriteLine(response);

import com.salad.cloud.sdk.SaladCloudSdk;
import com.salad.cloud.sdk.config.ApiKeyAuthConfig;
import com.salad.cloud.sdk.config.SaladCloudSdkConfig;
import com.salad.cloud.sdk.models.AxiomLoggingConfiguration;
import com.salad.cloud.sdk.models.ContainerConfiguration;
import com.salad.cloud.sdk.models.ContainerConfigurationLogging;
import com.salad.cloud.sdk.models.ContainerGroup;
import com.salad.cloud.sdk.models.ContainerGroupCreationRequest;
import com.salad.cloud.sdk.models.ContainerGroupGRpcProbe;
import com.salad.cloud.sdk.models.ContainerGroupHttpProbeConfiguration;
import com.salad.cloud.sdk.models.ContainerGroupLivenessProbe;
import com.salad.cloud.sdk.models.ContainerGroupPriority;
import com.salad.cloud.sdk.models.ContainerGroupProbeExec;
import com.salad.cloud.sdk.models.ContainerGroupProbeHttpHeader;
import com.salad.cloud.sdk.models.ContainerGroupQueueConnection;
import com.salad.cloud.sdk.models.ContainerGroupReadinessProbe;
import com.salad.cloud.sdk.models.ContainerGroupScalingAction;
import com.salad.cloud.sdk.models.ContainerGroupStartupProbe;
import com.salad.cloud.sdk.models.ContainerGroupTcpProbe;
import com.salad.cloud.sdk.models.ContainerLoggingConfigurationHttp2;
import com.salad.cloud.sdk.models.ContainerLoggingHttpCompression;
import com.salad.cloud.sdk.models.ContainerLoggingHttpFormat;
import com.salad.cloud.sdk.models.ContainerLoggingHttpHeader;
import com.salad.cloud.sdk.models.ContainerLoggingSplunkConfiguration;
import com.salad.cloud.sdk.models.ContainerNetworkingProtocol;
import com.salad.cloud.sdk.models.ContainerRegistryAuthentication;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationAwsEcr;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationBasic;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationDockerHub;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationGcpGar;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationGcpGcr;
import com.salad.cloud.sdk.models.ContainerRestartPolicy;
import com.salad.cloud.sdk.models.CountryCode;
import com.salad.cloud.sdk.models.CreateContainerGroupNetworking;
import com.salad.cloud.sdk.models.CreateContainerResourceRequirements;
import com.salad.cloud.sdk.models.DatadogLoggingConfiguration;
import com.salad.cloud.sdk.models.DatadogTagForContainerLogging;
import com.salad.cloud.sdk.models.HttpScheme;
import com.salad.cloud.sdk.models.NewRelicLoggingConfiguration;
import com.salad.cloud.sdk.models.QueueBasedAutoscalerConfiguration;
import com.salad.cloud.sdk.models.TcpLoggingConfiguration;
import com.salad.cloud.sdk.models.TheContainerGroupNetworkingLoadBalancer;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class Main {
    public static void main(String[] args) {
		SaladCloudSdkConfig config = SaladCloudSdkConfig.builder()
			.apiKeyAuthConfig(
				ApiKeyAuthConfig.builder()
					.apiKey("YOUR_API_KEY")
					.build()
			)
			.build();

		SaladCloudSdk saladCloudSdk = new SaladCloudSdk(config);

		List<String> commandList = Arrays.asList("command");

		AxiomLoggingConfiguration axiomLoggingConfiguration = AxiomLoggingConfiguration.builder()
			.apiToken("api_token")
			.dataset("dataset")
			.host("host")
			.build();

		DatadogTagForContainerLogging datadogTagForContainerLogging = DatadogTagForContainerLogging.builder()
			.name("name")
			.value("value")
			.build();

		List<DatadogTagForContainerLogging> tagsList = Arrays.asList(datadogTagForContainerLogging);

		DatadogLoggingConfiguration datadogLoggingConfiguration = DatadogLoggingConfiguration.builder()
			.apiKey("api_key")
			.host("host")
			.tags(tagsList)
			.build();

		ContainerLoggingHttpHeader containerLoggingHttpHeader = ContainerLoggingHttpHeader.builder()
			.name("name")
			.value("value")
			.build();

		List<ContainerLoggingHttpHeader> headersList = Arrays.asList(containerLoggingHttpHeader);

		ContainerLoggingConfigurationHttp2 containerLoggingConfigurationHttp2 = ContainerLoggingConfigurationHttp2.builder()
			.compression(ContainerLoggingHttpCompression.NONE)
			.format(ContainerLoggingHttpFormat.JSON)
			.headers(headersList)
			.host("host")
			.password("password")
			.path("path")
			.port(42056L)
			.user("user")
			.build();

		NewRelicLoggingConfiguration newRelicLoggingConfiguration = NewRelicLoggingConfiguration.builder()
			.host("host")
			.ingestionKey("ingestion_key")
			.build();

		ContainerLoggingSplunkConfiguration containerLoggingSplunkConfiguration = ContainerLoggingSplunkConfiguration.builder()
			.host("host")
			.token("token")
			.build();

		TcpLoggingConfiguration tcpLoggingConfiguration = TcpLoggingConfiguration.builder()
			.host("host")
			.port(44671L)
			.build();

		ContainerConfigurationLogging containerConfigurationLogging = ContainerConfigurationLogging.builder()
			.axiom(axiomLoggingConfiguration)
			.datadog(datadogLoggingConfiguration)
			.http(containerLoggingConfigurationHttp2)
			.newRelic(newRelicLoggingConfiguration)
			.splunk(containerLoggingSplunkConfiguration)
			.tcp(tcpLoggingConfiguration)
			.build();

		ContainerRegistryAuthenticationAwsEcr containerRegistryAuthenticationAwsEcr = ContainerRegistryAuthenticationAwsEcr.builder()
			.accessKeyId("access_key_id")
			.secretAccessKey("secret_access_key")
			.build();

		ContainerRegistryAuthenticationBasic containerRegistryAuthenticationBasic = ContainerRegistryAuthenticationBasic.builder()
			.password("password")
			.username("username")
			.build();

		ContainerRegistryAuthenticationDockerHub containerRegistryAuthenticationDockerHub = ContainerRegistryAuthenticationDockerHub.builder()
			.personalAccessToken("personal_access_token")
			.username("username")
			.build();

		ContainerRegistryAuthenticationGcpGar containerRegistryAuthenticationGcpGar = ContainerRegistryAuthenticationGcpGar.builder()
			.serviceKey("service_key")
			.build();

		ContainerRegistryAuthenticationGcpGcr containerRegistryAuthenticationGcpGcr = ContainerRegistryAuthenticationGcpGcr.builder()
			.serviceKey("service_key")
			.build();

		ContainerRegistryAuthentication containerRegistryAuthentication = ContainerRegistryAuthentication.builder()
			.awsEcr(containerRegistryAuthenticationAwsEcr)
			.basic(containerRegistryAuthenticationBasic)
			.dockerHub(containerRegistryAuthenticationDockerHub)
			.gcpGar(containerRegistryAuthenticationGcpGar)
			.gcpGcr(containerRegistryAuthenticationGcpGcr)
			.build();

		List<String> gpuClassesList = Arrays.asList("gpu_classes");

		CreateContainerResourceRequirements createContainerResourceRequirements = CreateContainerResourceRequirements.builder()
			.cpu(827L)
			.gpuClasses(gpuClassesList)
			.memory(734164836L)
			.shmSize(64L)
			.storageAmount(761306530849177.9L)
			.build();

		ContainerConfiguration containerConfiguration = ContainerConfiguration.builder()
			.command(commandList)
			.environmentVariables(new HashMap())
			.image("acme/:latest")
			.imageCaching(true)
			.logging(containerConfigurationLogging)
			.priority(ContainerGroupPriority.HIGH)
			.registryAuthentication(containerRegistryAuthentication)
			.resources(createContainerResourceRequirements)
			.build();

		List<CountryCode> countryCodesList = Arrays.asList(CountryCode.AF);

		List<String> commandList1 = Arrays.asList("command");

		ContainerGroupProbeExec containerGroupProbeExec = ContainerGroupProbeExec.builder()
			.command(commandList1)
			.build();

		ContainerGroupGRpcProbe containerGroupGRpcProbe = ContainerGroupGRpcProbe.builder()
			.port(37648L)
			.service("service")
			.build();

		ContainerGroupProbeHttpHeader containerGroupProbeHttpHeader = ContainerGroupProbeHttpHeader.builder()
			.name("name")
			.value("value")
			.build();

		List<ContainerGroupProbeHttpHeader> headersList1 = Arrays.asList(containerGroupProbeHttpHeader);

		ContainerGroupHttpProbeConfiguration containerGroupHttpProbeConfiguration = ContainerGroupHttpProbeConfiguration.builder()
			.headers(headersList1)
			.path("path")
			.port(29069L)
			.scheme(HttpScheme.HTTP)
			.build();

		ContainerGroupTcpProbe containerGroupTcpProbe = ContainerGroupTcpProbe.builder()
			.port(13817L)
			.build();

		ContainerGroupLivenessProbe containerGroupLivenessProbe = ContainerGroupLivenessProbe.builder()
			.exec(containerGroupProbeExec)
			.failureThreshold(3L)
			.grpc(containerGroupGRpcProbe)
			.http(containerGroupHttpProbeConfiguration)
			.initialDelaySeconds(670L)
			.periodSeconds(10L)
			.successThreshold(1L)
			.tcp(containerGroupTcpProbe)
			.timeoutSeconds(30L)
			.build();

		CreateContainerGroupNetworking createContainerGroupNetworking = CreateContainerGroupNetworking.builder()
			.auth(false)
			.clientRequestTimeout(100000L)
			.loadBalancer(TheContainerGroupNetworkingLoadBalancer.ROUND_ROBIN)
			.port(60000L)
			.protocol(ContainerNetworkingProtocol.HTTP)
			.serverResponseTimeout(100000L)
			.singleConnectionLimit(false)
			.build();

		QueueBasedAutoscalerConfiguration queueBasedAutoscalerConfiguration = QueueBasedAutoscalerConfiguration.builder()
			.desiredQueueLength(53L)
			.maxDownscalePerMinute(59L)
			.maxReplicas(321L)
			.maxUpscalePerMinute(100L)
			.minReplicas(54L)
			.pollingPeriod(140L)
			.build();

		ContainerGroupQueueConnection containerGroupQueueConnection = ContainerGroupQueueConnection.builder()
			.path("path")
			.port(47568L)
			.queueName("z1h-3z01x9")
			.build();

		ContainerGroupReadinessProbe containerGroupReadinessProbe = ContainerGroupReadinessProbe.builder()
			.exec(containerGroupProbeExec)
			.failureThreshold(3L)
			.grpc(containerGroupGRpcProbe)
			.http(containerGroupHttpProbeConfiguration)
			.initialDelaySeconds(262L)
			.periodSeconds(1L)
			.successThreshold(1L)
			.tcp(containerGroupTcpProbe)
			.timeoutSeconds(1L)
			.build();

		ContainerGroupScalingAction containerGroupScalingAction = ContainerGroupScalingAction.builder()
			.replicas(461L)
			.schedule("7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT")
			.build();

		List<ContainerGroupScalingAction> scalingActionsList = Arrays.asList(containerGroupScalingAction);

		ContainerGroupStartupProbe containerGroupStartupProbe = ContainerGroupStartupProbe.builder()
			.exec(containerGroupProbeExec)
			.failureThreshold(15L)
			.grpc(containerGroupGRpcProbe)
			.http(containerGroupHttpProbeConfiguration)
			.initialDelaySeconds(503L)
			.periodSeconds(3L)
			.successThreshold(2L)
			.tcp(containerGroupTcpProbe)
			.timeoutSeconds(10L)
			.build();

		ContainerGroupCreationRequest containerGroupCreationRequest = ContainerGroupCreationRequest.builder()
			.autostartPolicy(false)
			.container(containerConfiguration)
			.countryCodes(countryCodesList)
			.displayName("KMg0KyVwpb")
			.livenessProbe(containerGroupLivenessProbe)
			.name("name")
			.networking(createContainerGroupNetworking)
			.queueAutoscaler(queueBasedAutoscalerConfiguration)
			.queueConnection(containerGroupQueueConnection)
			.readinessProbe(containerGroupReadinessProbe)
			.replicas(77L)
			.restartPolicy(ContainerRestartPolicy.ALWAYS)
			.scalingActions(scalingActionsList)
			.scheduledScalingEnabled(true)
			.startupProbe(containerGroupStartupProbe)
			.build();

		ContainerGroup response = saladCloudSdk.containerGroups.createContainerGroup("acme-corp", "dev-env", containerGroupCreationRequest);

		System.out.println(response);
    }
}

import (
  "fmt"
  "encoding/json"
  "context"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/saladcloudsdkconfig"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/saladcloudsdk"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/util"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/containergroups"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/shared"
)

config := saladcloudsdkconfig.NewConfig()
config.SetApiKey("API_KEY")
client := saladcloudsdk.NewSaladCloudSdk(config)


axiomLoggingConfiguration := shared.AxiomLoggingConfiguration{
  ApiToken: util.ToPointer("api_token"),
  Dataset: util.ToPointer("dataset"),
  Host: util.ToPointer("host"),
}


datadogTagForContainerLogging := shared.DatadogTagForContainerLogging{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

datadogLoggingConfiguration := shared.DatadogLoggingConfiguration{
  ApiKey: util.ToPointer("api_key"),
  Host: util.ToPointer("host"),
  Tags: []shared.DatadogTagForContainerLogging{datadogTagForContainerLogging},
}

containerLoggingHttpCompression := shared.CONTAINER_LOGGING_HTTP_COMPRESSION_NONE

containerLoggingHttpFormat := shared.CONTAINER_LOGGING_HTTP_FORMAT_JSON


containerLoggingHttpHeader := shared.ContainerLoggingHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

containerLoggingConfigurationHttp2 := containergroups.ContainerLoggingConfigurationHttp2{
  Compression: &containerLoggingHttpCompression,
  Format: &containerLoggingHttpFormat,
  Headers: []shared.ContainerLoggingHttpHeader{containerLoggingHttpHeader},
  Host: util.ToPointer("host"),
  Password: util.ToPointer(util.Nullable[string]{ Value: "password" }),
  Path: util.ToPointer(util.Nullable[string]{ Value: "path" }),
  Port: util.ToPointer(int64(42056)),
  User: util.ToPointer(util.Nullable[string]{ Value: "user" }),
}


newRelicLoggingConfiguration := shared.NewRelicLoggingConfiguration{
  Host: util.ToPointer("host"),
  IngestionKey: util.ToPointer("ingestion_key"),
}


containerLoggingSplunkConfiguration := shared.ContainerLoggingSplunkConfiguration{
  Host: util.ToPointer("host"),
  Token: util.ToPointer("token"),
}


tcpLoggingConfiguration := shared.TcpLoggingConfiguration{
  Host: util.ToPointer("host"),
  Port: util.ToPointer(int64(44671)),
}

containerConfigurationLogging := containergroups.ContainerConfigurationLogging{
  Axiom: &axiomLoggingConfiguration,
  Datadog: &datadogLoggingConfiguration,
  Http: &containerLoggingConfigurationHttp2,
  NewRelic: &newRelicLoggingConfiguration,
  Splunk: &containerLoggingSplunkConfiguration,
  Tcp: &tcpLoggingConfiguration,
}

containerGroupPriority := shared.CONTAINER_GROUP_PRIORITY_HIGH


containerRegistryAuthenticationAwsEcr := containergroups.ContainerRegistryAuthenticationAwsEcr{
  AccessKeyId: util.ToPointer("access_key_id"),
  SecretAccessKey: util.ToPointer("secret_access_key"),
}


containerRegistryAuthenticationBasic := containergroups.ContainerRegistryAuthenticationBasic{
  Password: util.ToPointer("password"),
  Username: util.ToPointer("username"),
}


containerRegistryAuthenticationDockerHub := containergroups.ContainerRegistryAuthenticationDockerHub{
  PersonalAccessToken: util.ToPointer("personal_access_token"),
  Username: util.ToPointer("username"),
}


containerRegistryAuthenticationGcpGar := containergroups.ContainerRegistryAuthenticationGcpGar{
  ServiceKey: util.ToPointer("service_key"),
}


containerRegistryAuthenticationGcpGcr := containergroups.ContainerRegistryAuthenticationGcpGcr{
  ServiceKey: util.ToPointer("service_key"),
}

containerRegistryAuthentication := containergroups.ContainerRegistryAuthentication{
  AwsEcr: &containerRegistryAuthenticationAwsEcr,
  Basic: &containerRegistryAuthenticationBasic,
  DockerHub: &containerRegistryAuthenticationDockerHub,
  GcpGar: &containerRegistryAuthenticationGcpGar,
  GcpGcr: &containerRegistryAuthenticationGcpGcr,
}


createContainerResourceRequirements := containergroups.CreateContainerResourceRequirements{
  Cpu: util.ToPointer(int64(827)),
  GpuClasses: []string{},
  Memory: util.ToPointer(int64(734164836)),
  ShmSize: util.ToPointer(int64(64)),
  StorageAmount: util.ToPointer(int64(761306530849177.9)),
}

containerConfiguration := containergroups.ContainerConfiguration{
  Command: []string{},
  EnvironmentVariables: map[string]string{},
  Image: util.ToPointer("acme/:latest"),
  ImageCaching: util.ToPointer(true),
  Logging: &containerConfigurationLogging,
  Priority: &containerGroupPriority,
  RegistryAuthentication: &containerRegistryAuthentication,
  Resources: &createContainerResourceRequirements,
}

countryCode := shared.COUNTRY_CODE_AF


containerGroupProbeExec := shared.ContainerGroupProbeExec{
  Command: []string{},
}


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(37648)),
  Service: util.ToPointer("service"),
}


containerGroupProbeHttpHeader := shared.ContainerGroupProbeHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

httpScheme := shared.HTTP_SCHEME_HTTP

containerGroupHttpProbeConfiguration := shared.ContainerGroupHttpProbeConfiguration{
  Headers: []shared.ContainerGroupProbeHttpHeader{containerGroupProbeHttpHeader},
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(29069)),
  Scheme: &httpScheme,
}


containerGroupTcpProbe := shared.ContainerGroupTcpProbe{
  Port: util.ToPointer(int64(13817)),
}

containerGroupLivenessProbe := shared.ContainerGroupLivenessProbe{
  Exec: &containerGroupProbeExec,
  FailureThreshold: util.ToPointer(int64(3)),
  Grpc: &containerGroupGRpcProbe,
  Http: &containerGroupHttpProbeConfiguration,
  InitialDelaySeconds: util.ToPointer(int64(670)),
  PeriodSeconds: util.ToPointer(int64(10)),
  SuccessThreshold: util.ToPointer(int64(1)),
  Tcp: &containerGroupTcpProbe,
  TimeoutSeconds: util.ToPointer(int64(30)),
}

theContainerGroupNetworkingLoadBalancer := shared.THE_CONTAINER_GROUP_NETWORKING_LOAD_BALANCER_ROUND_ROBIN

containerNetworkingProtocol := shared.CONTAINER_NETWORKING_PROTOCOL_HTTP

createContainerGroupNetworking := containergroups.CreateContainerGroupNetworking{
  Auth: util.ToPointer(true),
  ClientRequestTimeout: util.ToPointer(int64(100000)),
  LoadBalancer: &theContainerGroupNetworkingLoadBalancer,
  Port: util.ToPointer(int64(60000)),
  Protocol: &containerNetworkingProtocol,
  ServerResponseTimeout: util.ToPointer(int64(100000)),
  SingleConnectionLimit: util.ToPointer(true),
}


queueBasedAutoscalerConfiguration := shared.QueueBasedAutoscalerConfiguration{
  DesiredQueueLength: util.ToPointer(int64(53)),
  MaxDownscalePerMinute: util.ToPointer(int64(59)),
  MaxReplicas: util.ToPointer(int64(321)),
  MaxUpscalePerMinute: util.ToPointer(int64(100)),
  MinReplicas: util.ToPointer(int64(54)),
  PollingPeriod: util.ToPointer(int64(140)),
}


containerGroupQueueConnection := shared.ContainerGroupQueueConnection{
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(47568)),
  QueueName: util.ToPointer("z1h-3z01x9"),
}


containerGroupProbeExec := shared.ContainerGroupProbeExec{
  Command: []string{},
}


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(37648)),
  Service: util.ToPointer("service"),
}


containerGroupProbeHttpHeader := shared.ContainerGroupProbeHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

httpScheme := shared.HTTP_SCHEME_HTTP

containerGroupHttpProbeConfiguration := shared.ContainerGroupHttpProbeConfiguration{
  Headers: []shared.ContainerGroupProbeHttpHeader{containerGroupProbeHttpHeader},
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(29069)),
  Scheme: &httpScheme,
}


containerGroupTcpProbe := shared.ContainerGroupTcpProbe{
  Port: util.ToPointer(int64(13817)),
}

containerGroupReadinessProbe := shared.ContainerGroupReadinessProbe{
  Exec: &containerGroupProbeExec,
  FailureThreshold: util.ToPointer(int64(3)),
  Grpc: &containerGroupGRpcProbe,
  Http: &containerGroupHttpProbeConfiguration,
  InitialDelaySeconds: util.ToPointer(int64(262)),
  PeriodSeconds: util.ToPointer(int64(1)),
  SuccessThreshold: util.ToPointer(int64(1)),
  Tcp: &containerGroupTcpProbe,
  TimeoutSeconds: util.ToPointer(int64(1)),
}

containerRestartPolicy := shared.CONTAINER_RESTART_POLICY_ALWAYS


containerGroupScalingAction := shared.ContainerGroupScalingAction{
  Replicas: util.ToPointer(int64(461)),
  Schedule: util.ToPointer("7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT"),
}


containerGroupProbeExec := shared.ContainerGroupProbeExec{
  Command: []string{},
}


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(37648)),
  Service: util.ToPointer("service"),
}


containerGroupProbeHttpHeader := shared.ContainerGroupProbeHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

httpScheme := shared.HTTP_SCHEME_HTTP

containerGroupHttpProbeConfiguration := shared.ContainerGroupHttpProbeConfiguration{
  Headers: []shared.ContainerGroupProbeHttpHeader{containerGroupProbeHttpHeader},
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(29069)),
  Scheme: &httpScheme,
}


containerGroupTcpProbe := shared.ContainerGroupTcpProbe{
  Port: util.ToPointer(int64(13817)),
}

containerGroupStartupProbe := shared.ContainerGroupStartupProbe{
  Exec: &containerGroupProbeExec,
  FailureThreshold: util.ToPointer(int64(15)),
  Grpc: &containerGroupGRpcProbe,
  Http: &containerGroupHttpProbeConfiguration,
  InitialDelaySeconds: util.ToPointer(int64(503)),
  PeriodSeconds: util.ToPointer(int64(3)),
  SuccessThreshold: util.ToPointer(int64(2)),
  Tcp: &containerGroupTcpProbe,
  TimeoutSeconds: util.ToPointer(int64(10)),
}

request := containergroups.ContainerGroupCreationRequest{
  AutostartPolicy: util.ToPointer(true),
  Container: &containerConfiguration,
  CountryCodes: []shared.CountryCode{countryCode},
  DisplayName: util.ToPointer("KMg0KyVwpb"),
  LivenessProbe: &containerGroupLivenessProbe,
  Name: util.ToPointer("name"),
  Networking: &createContainerGroupNetworking,
  QueueAutoscaler: &queueBasedAutoscalerConfiguration,
  QueueConnection: &containerGroupQueueConnection,
  ReadinessProbe: &containerGroupReadinessProbe,
  Replicas: util.ToPointer(int64(77)),
  RestartPolicy: &containerRestartPolicy,
  ScalingActions: []shared.ContainerGroupScalingAction{containerGroupScalingAction},
  ScheduledScalingEnabled: util.ToPointer(true),
  StartupProbe: &containerGroupStartupProbe,
}

response, err := client.ContainerGroups.CreateContainerGroup(context.Background(), "acme-corp", "dev-env", request)
if err != nil {
  panic(err)
}

fmt.Println(response)

import {
  AxiomLoggingConfiguration,
  ContainerConfiguration,
  ContainerConfigurationLogging,
  ContainerGroupCreationRequest,
  ContainerGroupGRpcProbe,
  ContainerGroupHttpProbeConfiguration,
  ContainerGroupLivenessProbe,
  ContainerGroupPriority,
  ContainerGroupProbeExec,
  ContainerGroupProbeHttpHeader,
  ContainerGroupQueueConnection,
  ContainerGroupReadinessProbe,
  ContainerGroupScalingAction,
  ContainerGroupStartupProbe,
  ContainerGroupTcpProbe,
  ContainerLoggingConfigurationHttp2,
  ContainerLoggingHttpCompression,
  ContainerLoggingHttpFormat,
  ContainerLoggingHttpHeader,
  ContainerLoggingSplunkConfiguration,
  ContainerNetworkingProtocol,
  ContainerRegistryAuthentication,
  ContainerRegistryAuthenticationAwsEcr,
  ContainerRegistryAuthenticationBasic,
  ContainerRegistryAuthenticationDockerHub,
  ContainerRegistryAuthenticationGcpGar,
  ContainerRegistryAuthenticationGcpGcr,
  ContainerRestartPolicy,
  CountryCode,
  CreateContainerGroupNetworking,
  CreateContainerResourceRequirements,
  DatadogLoggingConfiguration,
  DatadogTagForContainerLogging,
  HttpScheme,
  NewRelicLoggingConfiguration,
  QueueBasedAutoscalerConfiguration,
  SaladCloudSdk,
  TcpLoggingConfiguration,
  TheContainerGroupNetworkingLoadBalancer,
} from '@saladtechnologies-oss/salad-cloud-sdk';

(async () => {
  const saladCloudSdk = new SaladCloudSdk({
    apiKey: 'YOUR_API_KEY',
  });

  const axiomLoggingConfiguration: AxiomLoggingConfiguration = {
    apiToken: 'api_token',
    dataset: 'dataset',
    host: 'host',
  };

  const datadogTagForContainerLogging: DatadogTagForContainerLogging = {
    name: 'name',
    value: 'value',
  };

  const datadogLoggingConfiguration: DatadogLoggingConfiguration = {
    apiKey: 'api_key',
    host: 'host',
    tags: [datadogTagForContainerLogging],
  };

  const containerLoggingHttpCompression = ContainerLoggingHttpCompression.NONE;

  const containerLoggingHttpFormat = ContainerLoggingHttpFormat.JSON;

  const containerLoggingHttpHeader: ContainerLoggingHttpHeader = {
    name: 'name',
    value: 'value',
  };

  const containerLoggingConfigurationHttp2: ContainerLoggingConfigurationHttp2 = {
    compression: containerLoggingHttpCompression,
    format: containerLoggingHttpFormat,
    headers: [containerLoggingHttpHeader],
    host: 'host',
    password: 'password',
    path: 'path',
    port: 42056,
    user: 'user',
  };

  const newRelicLoggingConfiguration: NewRelicLoggingConfiguration = {
    host: 'host',
    ingestionKey: 'ingestion_key',
  };

  const containerLoggingSplunkConfiguration: ContainerLoggingSplunkConfiguration = {
    host: 'host',
    token: 'token',
  };

  const tcpLoggingConfiguration: TcpLoggingConfiguration = {
    host: 'host',
    port: 44671,
  };

  const containerConfigurationLogging: ContainerConfigurationLogging = {
    axiom: axiomLoggingConfiguration,
    datadog: datadogLoggingConfiguration,
    http: containerLoggingConfigurationHttp2,
    newRelic: newRelicLoggingConfiguration,
    splunk: containerLoggingSplunkConfiguration,
    tcp: tcpLoggingConfiguration,
  };

  const containerGroupPriority = ContainerGroupPriority.HIGH;

  const containerRegistryAuthenticationAwsEcr: ContainerRegistryAuthenticationAwsEcr = {
    accessKeyId: 'access_key_id',
    secretAccessKey: 'secret_access_key',
  };

  const containerRegistryAuthenticationBasic: ContainerRegistryAuthenticationBasic = {
    password: 'password',
    username: 'username',
  };

  const containerRegistryAuthenticationDockerHub: ContainerRegistryAuthenticationDockerHub = {
    personalAccessToken: 'personal_access_token',
    username: 'username',
  };

  const containerRegistryAuthenticationGcpGar: ContainerRegistryAuthenticationGcpGar = {
    serviceKey: 'service_key',
  };

  const containerRegistryAuthenticationGcpGcr: ContainerRegistryAuthenticationGcpGcr = {
    serviceKey: 'service_key',
  };

  const containerRegistryAuthentication: ContainerRegistryAuthentication = {
    awsEcr: containerRegistryAuthenticationAwsEcr,
    basic: containerRegistryAuthenticationBasic,
    dockerHub: containerRegistryAuthenticationDockerHub,
    gcpGar: containerRegistryAuthenticationGcpGar,
    gcpGcr: containerRegistryAuthenticationGcpGcr,
  };

  const createContainerResourceRequirements: CreateContainerResourceRequirements = {
    cpu: 827,
    gpuClasses: ['gpu_classes'],
    memory: 734164836,
    shmSize: 64,
    storageAmount: 761306530849177.9,
  };

  const containerConfiguration: ContainerConfiguration = {
    command: ['command'],
    environmentVariables: [],
    image: 'acme/:latest',
    imageCaching: true,
    logging: containerConfigurationLogging,
    priority: containerGroupPriority,
    registryAuthentication: containerRegistryAuthentication,
    resources: createContainerResourceRequirements,
  };

  const countryCode = CountryCode.AF;

  const containerGroupProbeExec: ContainerGroupProbeExec = {
    command: ['command'],
  };

  const containerGroupGRpcProbe: ContainerGroupGRpcProbe = {
    port: 37648,
    service: 'service',
  };

  const containerGroupProbeHttpHeader: ContainerGroupProbeHttpHeader = {
    name: 'name',
    value: 'value',
  };

  const httpScheme = HttpScheme.HTTP;

  const containerGroupHttpProbeConfiguration: ContainerGroupHttpProbeConfiguration = {
    headers: [containerGroupProbeHttpHeader],
    path: 'path',
    port: 29069,
    scheme: httpScheme,
  };

  const containerGroupTcpProbe: ContainerGroupTcpProbe = {
    port: 13817,
  };

  const containerGroupLivenessProbe: ContainerGroupLivenessProbe = {
    exec: containerGroupProbeExec,
    failureThreshold: 3,
    grpc: containerGroupGRpcProbe,
    http: containerGroupHttpProbeConfiguration,
    initialDelaySeconds: 670,
    periodSeconds: 10,
    successThreshold: 1,
    tcp: containerGroupTcpProbe,
    timeoutSeconds: 30,
  };

  const theContainerGroupNetworkingLoadBalancer = TheContainerGroupNetworkingLoadBalancer.ROUND_ROBIN;

  const containerNetworkingProtocol = ContainerNetworkingProtocol.HTTP;

  const createContainerGroupNetworking: CreateContainerGroupNetworking = {
    auth: true,
    clientRequestTimeout: 100000,
    loadBalancer: theContainerGroupNetworkingLoadBalancer,
    port: 60000,
    protocol: containerNetworkingProtocol,
    serverResponseTimeout: 100000,
    singleConnectionLimit: true,
  };

  const queueBasedAutoscalerConfiguration: QueueBasedAutoscalerConfiguration = {
    desiredQueueLength: 53,
    maxDownscalePerMinute: 59,
    maxReplicas: 321,
    maxUpscalePerMinute: 100,
    minReplicas: 54,
    pollingPeriod: 140,
  };

  const containerGroupQueueConnection: ContainerGroupQueueConnection = {
    path: 'path',
    port: 47568,
    queueName: 'z1h-3z01x9',
  };

  const containerGroupReadinessProbe: ContainerGroupReadinessProbe = {
    exec: containerGroupProbeExec,
    failureThreshold: 3,
    grpc: containerGroupGRpcProbe,
    http: containerGroupHttpProbeConfiguration,
    initialDelaySeconds: 262,
    periodSeconds: 1,
    successThreshold: 1,
    tcp: containerGroupTcpProbe,
    timeoutSeconds: 1,
  };

  const containerRestartPolicy = ContainerRestartPolicy.ALWAYS;

  const containerGroupScalingAction: ContainerGroupScalingAction = {
    replicas: 461,
    schedule: '7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT',
  };

  const containerGroupStartupProbe: ContainerGroupStartupProbe = {
    exec: containerGroupProbeExec,
    failureThreshold: 15,
    grpc: containerGroupGRpcProbe,
    http: containerGroupHttpProbeConfiguration,
    initialDelaySeconds: 503,
    periodSeconds: 3,
    successThreshold: 2,
    tcp: containerGroupTcpProbe,
    timeoutSeconds: 10,
  };

  const containerGroupCreationRequest: ContainerGroupCreationRequest = {
    autostartPolicy: true,
    container: containerConfiguration,
    countryCodes: [countryCode],
    displayName: 'KMg0KyVwpb',
    livenessProbe: containerGroupLivenessProbe,
    name: 'name',
    networking: createContainerGroupNetworking,
    queueAutoscaler: queueBasedAutoscalerConfiguration,
    queueConnection: containerGroupQueueConnection,
    readinessProbe: containerGroupReadinessProbe,
    replicas: 77,
    restartPolicy: containerRestartPolicy,
    scalingActions: [containerGroupScalingAction],
    scheduledScalingEnabled: true,
    startupProbe: containerGroupStartupProbe,
  };

  const { data } = await saladCloudSdk.containerGroups.createContainerGroup(
    'acme-corp',
    'dev-env',
    containerGroupCreationRequest,
  );

  console.log(data);
})();

from salad_cloud_sdk import SaladCloudSdk
from salad_cloud_sdk.models import ContainerGroupCreationRequest

sdk = SaladCloudSdk(
    api_key="YOUR_API_KEY",
    api_key_header="YOUR_API_KEY_HEADER",
    timeout=10000
)

request_body = ContainerGroupCreationRequest(
    autostart_policy=False,
    container={
        "command": [
            "command"
        ],
        "environment_variables": {},
        "image": "acme/:latest",
        "image_caching": True,
        "logging": {
            "axiom": {
                "api_token": "api_token",
                "dataset": "dataset",
                "host": "host"
            },
            "datadog": {
                "api_key": "api_key",
                "host": "host",
                "tags": [
                    {
                        "name": "name",
                        "value": "value"
                    }
                ]
            },
            "http": {
                "compression": "none",
                "format": "json",
                "headers": [
                    {
                        "name": "name",
                        "value": "value"
                    }
                ],
                "host": "host",
                "password": "password",
                "path": "path",
                "port": 42056,
                "user": "user"
            },
            "new_relic": {
                "host": "host",
                "ingestion_key": "ingestion_key"
            },
            "splunk": {
                "host": "host",
                "token": "token"
            },
            "tcp": {
                "host": "host",
                "port": 44671
            }
        },
        "priority": "high",
        "registry_authentication": {
            "aws_ecr": {
                "access_key_id": "access_key_id",
                "secret_access_key": "secret_access_key"
            },
            "basic": {
                "password": "password",
                "username": "username"
            },
            "docker_hub": {
                "personal_access_token": "personal_access_token",
                "username": "username"
            },
            "gcp_gar": {
                "service_key": "service_key"
            },
            "gcp_gcr": {
                "service_key": "service_key"
            }
        },
        "resources": {
            "cpu": 827,
            "gpu_classes": [
                "gpu_classes"
            ],
            "memory": 734164836,
            "shm_size": 64,
            "storage_amount": 761306530849177.9
        }
    },
    country_codes=[
        "af"
    ],
    display_name="KMg0KyVwpb",
    liveness_probe={
        "exec_": {
            "command": [
                "command"
            ]
        },
        "failure_threshold": 3,
        "grpc": {
            "port": 37648,
            "service": "service"
        },
        "http": {
            "headers": [
                {
                    "name": "name",
                    "value": "value"
                }
            ],
            "path": "path",
            "port": 29069,
            "scheme": "http"
        },
        "initial_delay_seconds": 670,
        "period_seconds": 10,
        "success_threshold": 1,
        "tcp": {
            "port": 13817
        },
        "timeout_seconds": 30
    },
    name="name",
    networking={
        "auth": False,
        "client_request_timeout": 100000,
        "load_balancer": "round_robin",
        "port": 60000,
        "protocol": "http",
        "server_response_timeout": 100000,
        "single_connection_limit": False
    },
    queue_autoscaler={
        "desired_queue_length": 53,
        "max_downscale_per_minute": 59,
        "max_replicas": 321,
        "max_upscale_per_minute": 100,
        "min_replicas": 54,
        "polling_period": 140
    },
    queue_connection={
        "path": "path",
        "port": 47568,
        "queue_name": "z1h-3z01x9"
    },
    readiness_probe={
        "exec_": {
            "command": [
                "command"
            ]
        },
        "failure_threshold": 3,
        "grpc": {
            "port": 37648,
            "service": "service"
        },
        "http": {
            "headers": [
                {
                    "name": "name",
                    "value": "value"
                }
            ],
            "path": "path",
            "port": 29069,
            "scheme": "http"
        },
        "initial_delay_seconds": 262,
        "period_seconds": 1,
        "success_threshold": 1,
        "tcp": {
            "port": 13817
        },
        "timeout_seconds": 1
    },
    replicas=77,
    restart_policy="always",
    scaling_actions=[
        {
            "replicas": 461,
            "schedule": "7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT"
        }
    ],
    scheduled_scaling_enabled=True,
    startup_probe={
        "exec_": {
            "command": [
                "command"
            ]
        },
        "failure_threshold": 15,
        "grpc": {
            "port": 37648,
            "service": "service"
        },
        "http": {
            "headers": [
                {
                    "name": "name",
                    "value": "value"
                }
            ],
            "path": "path",
            "port": 29069,
            "scheme": "http"
        },
        "initial_delay_seconds": 503,
        "period_seconds": 3,
        "success_threshold": 2,
        "tcp": {
            "port": 13817
        },
        "timeout_seconds": 10
    }
)

result = sdk.container_groups.create_container_group(
    request_body=request_body,
    organization_name="acme-corp",
    project_name="dev-env"
)

print(result)

curl --request POST \
  --url https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers \
  --header 'Content-Type: application/json' \
  --header 'Salad-Api-Key: <api-key>' \
  --data '
{
  "autostart_policy": true,
  "container": {
    "image": "<string>",
    "resources": {
      "cpu": 512,
      "memory": 536871424,
      "gpu_classes": [
        "3c90c3cc-0d44-4b50-8888-8dd25736052a"
      ],
      "shm_size": 64,
      "storage_amount": 562950490292224
    },
    "command": [
      "<string>"
    ],
    "environment_variables": {},
    "image_caching": true,
    "logging": {},
    "registry_authentication": {
      "aws_ecr": {
        "access_key_id": "<string>",
        "secret_access_key": "<string>"
      }
    }
  },
  "name": "<string>",
  "replicas": 250,
  "country_codes": [
    "us"
  ],
  "display_name": "<string>",
  "liveness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 10,
    "success_threshold": 1,
    "timeout_seconds": 30
  },
  "readiness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 1,
    "success_threshold": 1,
    "timeout_seconds": 1
  },
  "scaling-actions": [
    {
      "replicas": 250,
      "schedule": "<string>"
    }
  ],
  "scheduled-scaling-enabled": true,
  "startup_probe": {
    "failure_threshold": 15,
    "initial_delay_seconds": 0,
    "period_seconds": 3,
    "success_threshold": 2,
    "timeout_seconds": 10
  }
}
'

const options = {
  method: 'POST',
  headers: {'Salad-Api-Key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    autostart_policy: true,
    container: {
      image: '<string>',
      resources: {
        cpu: 512,
        memory: 536871424,
        gpu_classes: ['3c90c3cc-0d44-4b50-8888-8dd25736052a'],
        shm_size: 64,
        storage_amount: 562950490292224
      },
      command: ['<string>'],
      environment_variables: {},
      image_caching: true,
      logging: {},
      registry_authentication: {aws_ecr: {access_key_id: '<string>', secret_access_key: '<string>'}}
    },
    name: '<string>',
    replicas: 250,
    country_codes: ['us'],
    display_name: '<string>',
    liveness_probe: {
      failure_threshold: 3,
      initial_delay_seconds: 0,
      period_seconds: 10,
      success_threshold: 1,
      timeout_seconds: 30
    },
    readiness_probe: {
      failure_threshold: 3,
      initial_delay_seconds: 0,
      period_seconds: 1,
      success_threshold: 1,
      timeout_seconds: 1
    },
    'scaling-actions': [{replicas: 250, schedule: '<string>'}],
    'scheduled-scaling-enabled': true,
    startup_probe: {
      failure_threshold: 15,
      initial_delay_seconds: 0,
      period_seconds: 3,
      success_threshold: 2,
      timeout_seconds: 10
    }
  })
};

fetch('https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'autostart_policy' => true,
    'container' => [
        'image' => '<string>',
        'resources' => [
                'cpu' => 512,
                'memory' => 536871424,
                'gpu_classes' => [
                                '3c90c3cc-0d44-4b50-8888-8dd25736052a'
                ],
                'shm_size' => 64,
                'storage_amount' => 562950490292224
        ],
        'command' => [
                '<string>'
        ],
        'environment_variables' => [
                
        ],
        'image_caching' => true,
        'logging' => [
                
        ],
        'registry_authentication' => [
                'aws_ecr' => [
                                'access_key_id' => '<string>',
                                'secret_access_key' => '<string>'
                ]
        ]
    ],
    'name' => '<string>',
    'replicas' => 250,
    'country_codes' => [
        'us'
    ],
    'display_name' => '<string>',
    'liveness_probe' => [
        'failure_threshold' => 3,
        'initial_delay_seconds' => 0,
        'period_seconds' => 10,
        'success_threshold' => 1,
        'timeout_seconds' => 30
    ],
    'readiness_probe' => [
        'failure_threshold' => 3,
        'initial_delay_seconds' => 0,
        'period_seconds' => 1,
        'success_threshold' => 1,
        'timeout_seconds' => 1
    ],
    'scaling-actions' => [
        [
                'replicas' => 250,
                'schedule' => '<string>'
        ]
    ],
    'scheduled-scaling-enabled' => true,
    'startup_probe' => [
        'failure_threshold' => 15,
        'initial_delay_seconds' => 0,
        'period_seconds' => 3,
        'success_threshold' => 2,
        'timeout_seconds' => 10
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "Salad-Api-Key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

require 'uri'
require 'net/http'

url = URI("https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Salad-Api-Key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"autostart_policy\": true,\n  \"container\": {\n    \"image\": \"<string>\",\n    \"resources\": {\n      \"cpu\": 512,\n      \"memory\": 536871424,\n      \"gpu_classes\": [\n        \"3c90c3cc-0d44-4b50-8888-8dd25736052a\"\n      ],\n      \"shm_size\": 64,\n      \"storage_amount\": 562950490292224\n    },\n    \"command\": [\n      \"<string>\"\n    ],\n    \"environment_variables\": {},\n    \"image_caching\": true,\n    \"logging\": {},\n    \"registry_authentication\": {\n      \"aws_ecr\": {\n        \"access_key_id\": \"<string>\",\n        \"secret_access_key\": \"<string>\"\n      }\n    }\n  },\n  \"name\": \"<string>\",\n  \"replicas\": 250,\n  \"country_codes\": [\n    \"us\"\n  ],\n  \"display_name\": \"<string>\",\n  \"liveness_probe\": {\n    \"failure_threshold\": 3,\n    \"initial_delay_seconds\": 0,\n    \"period_seconds\": 10,\n    \"success_threshold\": 1,\n    \"timeout_seconds\": 30\n  },\n  \"readiness_probe\": {\n    \"failure_threshold\": 3,\n    \"initial_delay_seconds\": 0,\n    \"period_seconds\": 1,\n    \"success_threshold\": 1,\n    \"timeout_seconds\": 1\n  },\n  \"scaling-actions\": [\n    {\n      \"replicas\": 250,\n      \"schedule\": \"<string>\"\n    }\n  ],\n  \"scheduled-scaling-enabled\": true,\n  \"startup_probe\": {\n    \"failure_threshold\": 15,\n    \"initial_delay_seconds\": 0,\n    \"period_seconds\": 3,\n    \"success_threshold\": 2,\n    \"timeout_seconds\": 10\n  }\n}"

response = http.request(request)
puts response.read_body

{
  "autostart_policy": true,
  "container": {
    "command": [
      "<string>"
    ],
    "image": "<string>",
    "resources": {
      "cpu": 512,
      "gpu_classes": [
        "3c90c3cc-0d44-4b50-8888-8dd25736052a"
      ],
      "memory": 536871424,
      "shm_size": 64,
      "storage_amount": 562950490292224
    },
    "environment_variables": {},
    "hash": "<string>",
    "image_caching": true,
    "logging": {
      "axiom": {
        "api_token": "<string>",
        "dataset": "<string>",
        "host": "<string>"
      },
      "datadog": {
        "api_key": "<string>",
        "host": "<string>",
        "tags": [
          {
            "name": "<string>",
            "value": "<string>"
          }
        ]
      },
      "http": {
        "headers": [
          {
            "name": "<string>",
            "value": "<string>"
          }
        ],
        "host": "<string>",
        "port": 32768,
        "password": "<string>",
        "path": "<string>",
        "user": "<string>"
      },
      "new_relic": {
        "host": "<string>",
        "ingestion_key": "<string>"
      },
      "splunk": {
        "host": "<string>",
        "token": "<string>"
      },
      "tcp": {
        "host": "<string>",
        "port": 32768
      }
    },
    "size": 4611686018427388000
  },
  "country_codes": [
    "us"
  ],
  "create_time": "2023-11-07T05:31:56Z",
  "current_state": {
    "finish_time": "2023-11-07T05:31:56Z",
    "instance_status_counts": {
      "allocating_count": 1073741823,
      "creating_count": 1073741823,
      "running_count": 1073741823,
      "stopping_count": 1073741823
    },
    "start_time": "2023-11-07T05:31:56Z",
    "description": "<string>"
  },
  "display_name": "<string>",
  "id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "name": "<string>",
  "organization_name": "<string>",
  "pending_change": true,
  "project_name": "<string>",
  "replicas": 250,
  "scaling-actions": [
    {
      "replicas": 250,
      "schedule": "<string>"
    }
  ],
  "scheduled-scaling-enabled": true,
  "update_time": "2023-11-07T05:31:56Z",
  "version": 1073741824,
  "liveness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 10,
    "success_threshold": 1,
    "timeout_seconds": 30,
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768
    },
    "tcp": {
      "port": 32767
    }
  },
  "networking": {
    "auth": true,
    "dns": "<string>",
    "load_balancer": "round_robin",
    "port": 32768,
    "protocol": "http",
    "client_request_timeout": 100000,
    "server_response_timeout": 100000,
    "single_connection_limit": false
  },
  "queue_autoscaler": {
    "desired_queue_length": 50,
    "max_replicas": 250,
    "min_replicas": 50,
    "max_downscale_per_minute": 50,
    "max_upscale_per_minute": 50,
    "polling_period": 907
  },
  "queue_connection": {
    "path": "<string>",
    "port": 32768,
    "queue_name": "<string>"
  },
  "readiness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 1,
    "success_threshold": 1,
    "timeout_seconds": 1,
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768
    },
    "tcp": {
      "port": 32767
    }
  },
  "readme": "<string>",
  "startup_probe": {
    "failure_threshold": 15,
    "initial_delay_seconds": 0,
    "period_seconds": 3,
    "success_threshold": 2,
    "timeout_seconds": 10,
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768
    },
    "tcp": {
      "port": 32767
    }
  }
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}