PATCH
/
organizations
/
{organization_name}
/
projects
/
{project_name}
/
containers
/
{container_group_name}
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"
)

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

containerLoggingConfigurationHttp1 := shared.ContainerLoggingConfigurationHttp1{
  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)),
}

updateContainerLogging := containergroups.UpdateContainerLogging{
  Axiom: &axiomLoggingConfiguration,
  Datadog: &datadogLoggingConfiguration,
  Http: &containerLoggingConfigurationHttp1,
  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,
}


containerResourceUpdateSchema := containergroups.ContainerResourceUpdateSchema{
  Cpu: util.ToPointer(util.Nullable[int64]{ Value: int64(123) }),
  Memory: util.ToPointer(util.Nullable[int64]{ Value: int64(123) }),
  GpuClasses: []string{},
  StorageAmount: util.ToPointer(util.Nullable[int64]{ Value: int64(123) }),
  ShmSize: util.ToPointer(util.Nullable[int64]{ Value: int64(123) }),
}

updateContainer := containergroups.UpdateContainer{
  Command: []string{},
  EnvironmentVariables: map[string]string{},
  Image: util.ToPointer(util.Nullable[string]{ Value: "Image" }),
  ImageCaching: util.ToPointer(true),
  Logging: &updateContainerLogging,
  Priority: &containerGroupPriority,
  RegistryAuthentication: &containerRegistryAuthentication,
  Resources: &containerResourceUpdateSchema,
}

countryCode := shared.COUNTRY_CODE_AF


updateContainerGroupNetworking := containergroups.UpdateContainerGroupNetworking{
  Port: util.ToPointer(util.Nullable[int64]{ Value: int64(123) }),
}


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)),
}


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)),
}


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)),
}


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)),
}

request := containergroups.ContainerGroupPatch{
  DisplayName: util.ToPointer(util.Nullable[string]{ Value: "DisplayName" }),
  Container: &updateContainer,
  Replicas: util.ToPointer(util.Nullable[int64]{ Value: int64(123) }),
  CountryCodes: []shared.CountryCode{countryCode},
  Networking: &updateContainerGroupNetworking,
  LivenessProbe: &containerGroupLivenessProbe,
  ReadinessProbe: &containerGroupReadinessProbe,
  StartupProbe: &containerGroupStartupProbe,
  QueueAutoscaler: &queueBasedAutoscalerConfiguration,
}

response, err := client.ContainerGroups.UpdateContainerGroup(context.Background(), "organizationName", "projectName", "containerGroupName", 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"

​
container_group_name
string
required

The unique container group name

Required string length: 2 - 63
Examples:

"mandlebrot"

Body

application/merge-patch+json

Represents a request to update a container group

​
display_name
string | null

The display name for the container group. If null is provided, the display name will be set to the container group name.

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

Represents an update container object

​
replicas
integer | null

The desired number of instances for your container group deployment.

Required range: 0 <= x <= 500
​
country_codes
enum<string>[] | null

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

Required array length: 1 - 500 elements
​
networking
object

Represents update container group networking parameters

​
liveness_probe
object | null

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

​
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.

​
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.

Response

OK

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.