POST
/
organizations
/
{organization_name}
/
projects
/
{project_name}
/
containers
Go
import (
  "fmt"
  "encoding/json"
  "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()
client := saladcloudsdk.NewSaladCloudSdk(config)


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


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

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

containerLoggingHttpFormat := shared.CONTAINER_LOGGING_HTTP_FORMAT_JSON


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

containerLoggingHttpCompression := shared.CONTAINER_LOGGING_HTTP_COMPRESSION_NONE

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


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


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


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

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("AccessKeyId"),
  SecretAccessKey: util.ToPointer("SecretAccessKey"),
}


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


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


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


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

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


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

containerConfiguration := containergroups.ContainerConfiguration{
  Command: []string{},
  EnvironmentVariables: map[string]string{},
  Image: util.ToPointer("Image"),
  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(123)),
  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(123)),
  Scheme: &httpScheme,
}


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

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

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(123)),
  LoadBalancer: &theContainerGroupNetworkingLoadBalancer,
  Port: util.ToPointer(int64(123)),
  Protocol: &containerNetworkingProtocol,
  ServerResponseTimeout: util.ToPointer(int64(123)),
  SingleConnectionLimit: util.ToPointer(true),
}


queueBasedAutoscalerConfiguration := shared.QueueBasedAutoscalerConfiguration{
  DesiredQueueLength: util.ToPointer(int64(123)),
  MaxReplicas: util.ToPointer(int64(123)),
  MaxDownscalePerMinute: util.ToPointer(int64(123)),
  MaxUpscalePerMinute: util.ToPointer(int64(123)),
  MinReplicas: util.ToPointer(int64(123)),
  PollingPeriod: util.ToPointer(int64(123)),
}


containerGroupQueueConnection := shared.ContainerGroupQueueConnection{
  Path: util.ToPointer("Path"),
  Port: util.ToPointer(int64(123)),
  QueueName: util.ToPointer("QueueName"),
}


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


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(123)),
  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(123)),
  Scheme: &httpScheme,
}


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

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

containerRestartPolicy := shared.CONTAINER_RESTART_POLICY_ALWAYS


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


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(123)),
  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(123)),
  Scheme: &httpScheme,
}


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

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

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

response, err := client.ContainerGroups.CreateContainerGroup(context.Background(), "organizationName", "projectName", request)
if err != nil {
  panic(err)
}

fmt.Println(response)
{
  "autostart_policy": true,
  "container": {
    "command": null,
    "environment_variables": {},
    "hash": "<string>",
    "image": "acme/:latest",
    "image_caching": true,
    "logging": {
      "axiom": {
        "host": "<string>",
        "api_token": "<string>",
        "dataset": "<string>"
      },
      "datadog": {
        "host": "<string>",
        "api_key": "<string>",
        "tags": [
          {
            "name": "<string>",
            "value": "<string>"
          }
        ]
      },
      "http": {
        "host": "<string>",
        "port": 32768,
        "user": "<string>",
        "password": "<string>",
        "path": "<string>",
        "format": "json",
        "headers": [
          {
            "name": "<string>",
            "value": "<string>"
          }
        ],
        "compression": "none"
      },
      "new_relic": {
        "host": "<string>",
        "ingestion_key": "<string>"
      },
      "splunk": {
        "host": "<string>",
        "token": "<string>"
      },
      "tcp": {
        "host": "<string>",
        "port": 32768
      }
    },
    "resources": {
      "cpu": 8,
      "memory": 31232,
      "gpu_classes": [
        "3c90c3cc-0d44-4b50-8888-8dd25736052a"
      ],
      "storage_amount": 134754598912,
      "shm_size": 64
    },
    "size": 4611686018427388000
  },
  "country_codes": [
    "af"
  ],
  "create_time": "2023-11-07T05:31:56Z",
  "current_state": {
    "description": "<string>",
    "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",
    "status": "pending"
  },
  "display_name": "Name",
  "id": "ab3a4591-efc3-46c0-b06a-3d820c0ec100",
  "liveness_probe": {
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "failure_threshold": 3,
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768,
      "scheme": "http"
    },
    "initial_delay_seconds": 0,
    "period_seconds": 10,
    "success_threshold": 1,
    "tcp": {
      "port": 32767
    },
    "timeout_seconds": 30
  },
  "name": "mandlebrot",
  "networking": {
    "auth": true,
    "client_request_timeout": 100000,
    "dns": "<string>",
    "load_balancer": "round_robin",
    "port": 60000,
    "protocol": "http",
    "server_response_timeout": 100000,
    "single_connection_limit": false
  },
  "organization_name": "acme-corp",
  "pending_change": true,
  "priority": "high",
  "project_name": "dev-env",
  "queue_autoscaler": {
    "desired_queue_length": 50,
    "max_replicas": 250,
    "max_downscale_per_minute": 50,
    "max_upscale_per_minute": 50,
    "min_replicas": 50,
    "polling_period": 907
  },
  "queue_connection": {
    "path": "<string>",
    "port": 32768,
    "queue_name": "<string>"
  },
  "readiness_probe": {
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "failure_threshold": 3,
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768,
      "scheme": "http"
    },
    "initial_delay_seconds": 0,
    "period_seconds": 1,
    "success_threshold": 1,
    "tcp": {
      "port": 32767
    },
    "timeout_seconds": 1
  },
  "readme": "<string>",
  "replicas": 50,
  "restart_policy": "always",
  "startup_probe": {
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "failure_threshold": 15,
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768,
      "scheme": "http"
    },
    "initial_delay_seconds": 0,
    "tcp": {
      "port": 32767
    },
    "period_seconds": 3,
    "success_threshold": 2,
    "timeout_seconds": 10
  },
  "update_time": "2023-11-07T05:31:56Z",
  "version": 1073741824
}
Last Updated: July 1, 2025

Authorizations

​
Salad-Api-Key
string
header
required

Path Parameters

​
organization_name
string
required

Your organization name. This identifies the billing context for the API operation and represents a security boundary for SaladCloud resources. The organization must be created before using the API, and you must be a member of the organization.

Required string length: 2 - 63
Examples:

"acme-corp"

​
project_name
string
required

Your project name. This represents a collection of related SaladCloud resources. The project must be created before using the API.

Required string length: 2 - 63
Examples:

"dev-env"

Body

application/json

Represents a request to create a container group, which manages a collection of container instances with shared configuration and scaling policies

​
autostart_policy
boolean
required

Determines whether the container group should start automatically when created (true) or remain stopped until manually started (false)

​
container
object
required

Configuration for creating a container within a container group. Defines the container image, resource requirements, environment variables, and other settings needed to deploy and run the container.

​
name
string
required

Unique identifier for the container group that must follow DNS naming conventions (lowercase alphanumeric with hyphens)

Required string length: 2 - 63
​
replicas
integer
required

Number of container instances to deploy and maintain for this container group

Required range: 0 <= x <= 500
​
restart_policy
enum<string>
required

Specifies the policy for restarting containers when they exit or fail.

Available options:
always,
on_failure,
never
​
country_codes
enum<string>[]

List of countries nodes must be located in. Remove this field to permit nodes from any country.

Required array length: 1 - 500 elements
​
display_name
string

Human-readable name for the container group that can include spaces and special characters, used for display purposes

Required string length: 2 - 63
​
liveness_probe
object | null

Defines a liveness probe for container groups that determines when to restart a container if it becomes unhealthy

​
networking
object

Network configuration for container groups specifying connectivity parameters, including authentication, protocol, and timeout settings

​
queue_autoscaler
object

Defines configuration for automatically scaling container instances based on queue length. The autoscaler monitors a queue and adjusts the number of running replicas to maintain the desired queue length.

​
queue_connection
object

Configuration for connecting a container group to a message queue system, enabling asynchronous communication between services.

​
readiness_probe
object | null

Defines how to check if a container is ready to serve traffic. The readiness probe determines whether the container's application is ready to accept traffic. If the readiness probe fails, the container is considered not ready and traffic will not be sent to it.

​
startup_probe
object | null

Defines a probe that checks if a container application has started successfully. Startup probes help prevent applications from being prematurely marked as unhealthy during initialization. The probe can use HTTP requests, TCP connections, gRPC calls, or shell commands to determine startup status.

Response

Created

A container group definition that represents a scalable set of identical containers running as a distributed service

​
autostart_policy
boolean
required

Defines whether containers in this group should automatically start when deployed (true) or require manual starting (false)

​
container
object
required

Represents a container with its configuration and resource requirements.

​
country_codes
enum<string>[]
required

List of country codes where container instances are permitted to run. When not specified or empty, containers may run in any available region.

Maximum length: 500
​
create_time
string<date-time>
required

ISO 8601 timestamp when this container group was initially created

​
current_state
object
required

Represents the operational state of a container group during its lifecycle, including timing information, status, and instance distribution metrics. This state captures the current execution status, start and finish times, and provides visibility into the operational health across instances.

​
display_name
string
required

The display-friendly name of the resource.

Required string length: 2 - 63
Examples:

"Name"

​
id
string<uuid>
required

The container group identifier.

Examples:

"ab3a4591-efc3-46c0-b06a-3d820c0ec100"

​
name
string
required

The container group name.

Required string length: 2 - 63
Examples:

"mandlebrot"

​
organization_name
string
required

The organization name.

Required string length: 2 - 63
Examples:

"acme-corp"

​
pending_change
boolean
required

Indicates whether a configuration change has been requested but not yet applied to all containers in the group

​
priority
enum<string> | null
required

Specifies the priority level for container group execution, which determines resource allocation and scheduling precedence.

Available options:
high,
medium,
low,
batch
​
project_name
string
required

The project name.

Required string length: 2 - 63
Examples:

"dev-env"

​
replicas
integer
required

The container group replicas.

Required range: 0 <= x <= 500
Examples:

50

​
restart_policy
enum<string>
required

Specifies the policy for restarting containers when they exit or fail.

Available options:
always,
on_failure,
never
​
update_time
string<date-time>
required

ISO 8601 timestamp when this container group was last updated

​
version
integer
required

Incremental version number that increases with each configuration change to the container group

Required range: 1 <= x <= 2147483647
​
liveness_probe
object | null

Defines a liveness probe for container groups that determines when to restart a container if it becomes unhealthy

​
networking
object

Network configuration for container groups that defines connectivity, routing, and access control settings

​
queue_autoscaler
object

Defines configuration for automatically scaling container instances based on queue length. The autoscaler monitors a queue and adjusts the number of running replicas to maintain the desired queue length.

​
queue_connection
object

Configuration for connecting a container group to a message queue system, enabling asynchronous communication between services.

​
readiness_probe
object | null

Defines how to check if a container is ready to serve traffic. The readiness probe determines whether the container's application is ready to accept traffic. If the readiness probe fails, the container is considered not ready and traffic will not be sent to it.

​
readme
string
Required string length: 2 - 65000
​
startup_probe
object | null

Defines a probe that checks if a container application has started successfully. Startup probes help prevent applications from being prematurely marked as unhealthy during initialization. The probe can use HTTP requests, TCP connections, gRPC calls, or shell commands to determine startup status.