scaleway.Container

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.containers.Namespace("main", {});
const mainContainer = new scaleway.containers.Container("main", {
    name: "my-container",
    description: "This container has a description.",
    tags: [
        "tag1",
        "tag2",
    ],
    namespaceId: main.id,
    image: "nginx:latest",
    port: 80,
    cpuLimit: 1024,
    memoryLimitBytes: 2048000000,
    minScale: 3,
    maxScale: 5,
    timeout: 600,
    protocol: "http1",
    commands: [
        "bash",
        "-c",
        "script.sh",
    ],
    args: [
        "some",
        "args",
    ],
    environmentVariables: {
        foo: "var",
    },
    secretEnvironmentVariables: {
        key: "secret",
    },
});

import pulumi
import pulumiverse_scaleway as scaleway

main = scaleway.containers.Namespace("main")
main_container = scaleway.containers.Container("main",
    name="my-container",
    description="This container has a description.",
    tags=[
        "tag1",
        "tag2",
    ],
    namespace_id=main.id,
    image="nginx:latest",
    port=80,
    cpu_limit=1024,
    memory_limit_bytes=2048000000,
    min_scale=3,
    max_scale=5,
    timeout=600,
    protocol="http1",
    commands=[
        "bash",
        "-c",
        "script.sh",
    ],
    args=[
        "some",
        "args",
    ],
    environment_variables={
        "foo": "var",
    },
    secret_environment_variables={
        "key": "secret",
    })

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/containers"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := containers.NewNamespace(ctx, "main", nil)
		if err != nil {
			return err
		}
		_, err = containers.NewContainer(ctx, "main", &containers.ContainerArgs{
			Name:        pulumi.String("my-container"),
			Description: pulumi.String("This container has a description."),
			Tags: pulumi.StringArray{
				pulumi.String("tag1"),
				pulumi.String("tag2"),
			},
			NamespaceId:      main.ID(),
			Image:            pulumi.String("nginx:latest"),
			Port:             pulumi.Int(80),
			CpuLimit:         pulumi.Int(1024),
			MemoryLimitBytes: pulumi.Int(2048000000),
			MinScale:         pulumi.Int(3),
			MaxScale:         pulumi.Int(5),
			Timeout:          pulumi.Int(600),
			Protocol:         pulumi.String("http1"),
			Commands: pulumi.StringArray{
				pulumi.String("bash"),
				pulumi.String("-c"),
				pulumi.String("script.sh"),
			},
			Args: pulumi.StringArray{
				pulumi.String("some"),
				pulumi.String("args"),
			},
			EnvironmentVariables: pulumi.StringMap{
				"foo": pulumi.String("var"),
			},
			SecretEnvironmentVariables: pulumi.StringMap{
				"key": pulumi.String("secret"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Containers.Namespace("main");

    var mainContainer = new Scaleway.Containers.Container("main", new()
    {
        Name = "my-container",
        Description = "This container has a description.",
        Tags = new[]
        {
            "tag1",
            "tag2",
        },
        NamespaceId = main.Id,
        Image = "nginx:latest",
        Port = 80,
        CpuLimit = 1024,
        MemoryLimitBytes = 2048000000,
        MinScale = 3,
        MaxScale = 5,
        Timeout = 600,
        Protocol = "http1",
        Commands = new[]
        {
            "bash",
            "-c",
            "script.sh",
        },
        Args = new[]
        {
            "some",
            "args",
        },
        EnvironmentVariables = 
        {
            { "foo", "var" },
        },
        SecretEnvironmentVariables = 
        {
            { "key", "secret" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.containers.Namespace;
import com.pulumi.scaleway.containers.Container;
import com.pulumi.scaleway.containers.ContainerArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var main = new Namespace("main");

        var mainContainer = new Container("mainContainer", ContainerArgs.builder()
            .name("my-container")
            .description("This container has a description.")
            .tags(            
                "tag1",
                "tag2")
            .namespaceId(main.id())
            .image("nginx:latest")
            .port(80)
            .cpuLimit(1024)
            .memoryLimitBytes(2048000000)
            .minScale(3)
            .maxScale(5)
            .timeout(600)
            .protocol("http1")
            .commands(            
                "bash",
                "-c",
                "script.sh")
            .args(            
                "some",
                "args")
            .environmentVariables(Map.of("foo", "var"))
            .secretEnvironmentVariables(Map.of("key", "secret"))
            .build());

    }
}

resources:
  main:
    type: scaleway:containers:Namespace
  mainContainer:
    type: scaleway:containers:Container
    name: main
    properties:
      name: my-container
      description: This container has a description.
      tags:
        - tag1
        - tag2
      namespaceId: ${main.id}
      image: nginx:latest
      port: 80
      cpuLimit: 1024
      memoryLimitBytes: 2.048e+09
      minScale: 3
      maxScale: 5
      timeout: 600
      protocol: http1
      commands:
        - bash
        - -c
        - script.sh
      args:
        - some
        - args
      environmentVariables:
        foo: var
      secretEnvironmentVariables:
        key: secret

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";
import * as std from "@pulumi/std";

const main = scaleway.registry.getNamespace({
    name: "my-registry",
});
const mainGetImage = main.then(main => scaleway.registry.getImage({
    namespaceId: main.id,
    name: "nginx-1-29-2-alpine",
}));
const mainNamespace = new scaleway.containers.Namespace("main", {});
const mainContainer = new scaleway.containers.Container("main", {
    name: "my-container",
    namespaceId: mainNamespace.id,
    image: Promise.all([main, mainGetImage, mainGetImage]).then(([main, mainGetImage, mainGetImage1]) => `${main.endpoint}/${mainGetImage.name}:${mainGetImage1.tags?.[0]}`),
    port: 80,
    registrySha256: std.timestamp({}).result,
});

import pulumi
import pulumi_scaleway as scaleway
import pulumi_std as std
import pulumiverse_scaleway as scaleway

main = scaleway.registry.get_namespace(name="my-registry")
main_get_image = scaleway.registry.get_image(namespace_id=main.id,
    name="nginx-1-29-2-alpine")
main_namespace = scaleway.containers.Namespace("main")
main_container = scaleway.containers.Container("main",
    name="my-container",
    namespace_id=main_namespace.id,
    image=f"{main.endpoint}/{main_get_image.name}:{main_get_image.tags[0]}",
    port=80,
    registry_sha256=std.timestamp()["result"])

package main

import (
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/containers"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/registry"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := registry.LookupNamespace(ctx, &registry.LookupNamespaceArgs{
			Name: pulumi.StringRef("my-registry"),
		}, nil)
		if err != nil {
			return err
		}
		mainGetImage, err := registry.GetImage(ctx, &registry.GetImageArgs{
			NamespaceId: pulumi.StringRef(main.Id),
			Name:        pulumi.StringRef("nginx-1-29-2-alpine"),
		}, nil)
		if err != nil {
			return err
		}
		mainNamespace, err := containers.NewNamespace(ctx, "main", nil)
		if err != nil {
			return err
		}
		invokeTimestamp, err := std.Timestamp(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		_, err = containers.NewContainer(ctx, "main", &containers.ContainerArgs{
			Name:           pulumi.String("my-container"),
			NamespaceId:    mainNamespace.ID(),
			Image:          pulumi.Sprintf("%v/%v:%v", main.Endpoint, mainGetImage.Name, mainGetImage.Tags[0]),
			Port:           pulumi.Int(80),
			RegistrySha256: invokeTimestamp.Result,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var main = Scaleway.Registry.GetNamespace.Invoke(new()
    {
        Name = "my-registry",
    });

    var mainGetImage = Scaleway.Registry.GetImage.Invoke(new()
    {
        NamespaceId = main.Apply(getNamespaceResult => getNamespaceResult.Id),
        Name = "nginx-1-29-2-alpine",
    });

    var mainNamespace = new Scaleway.Containers.Namespace("main");

    var mainContainer = new Scaleway.Containers.Container("main", new()
    {
        Name = "my-container",
        NamespaceId = mainNamespace.Id,
        Image = Output.Tuple(main, mainGetImage, mainGetImage).Apply(values =>
        {
            var main = values.Item1;
            var mainGetImage = values.Item2;
            var mainGetImage1 = values.Item3;
            return $"{main.Apply(getNamespaceResult => getNamespaceResult.Endpoint)}/{mainGetImage.Apply(getImageResult => getImageResult.Name)}:{mainGetImage1.Tags[0]}";
        }),
        Port = 80,
        RegistrySha256 = Std.Timestamp.Invoke().Result,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.registry.RegistryFunctions;
import com.pulumi.scaleway.registry.inputs.GetNamespaceArgs;
import com.pulumi.scaleway.registry.inputs.GetImageArgs;
import com.pulumi.scaleway.containers.Namespace;
import com.pulumi.scaleway.containers.Container;
import com.pulumi.scaleway.containers.ContainerArgs;
import com.pulumi.std.StdFunctions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var main = RegistryFunctions.getNamespace(GetNamespaceArgs.builder()
            .name("my-registry")
            .build());

        final var mainGetImage = RegistryFunctions.getImage(GetImageArgs.builder()
            .namespaceId(main.id())
            .name("nginx-1-29-2-alpine")
            .build());

        var mainNamespace = new Namespace("mainNamespace");

        var mainContainer = new Container("mainContainer", ContainerArgs.builder()
            .name("my-container")
            .namespaceId(mainNamespace.id())
            .image(String.format("%s/%s:%s", main.endpoint(),mainGetImage.name(),mainGetImage.tags()[0]))
            .port(80)
            .registrySha256(StdFunctions.timestamp(Map.ofEntries(
            )).result())
            .build());

    }
}

resources:
  mainNamespace:
    type: scaleway:containers:Namespace
    name: main
  mainContainer:
    type: scaleway:containers:Container
    name: main
    properties:
      name: my-container
      namespaceId: ${mainNamespace.id}
      image: ${main.endpoint}/${mainGetImage.name}:${mainGetImage.tags[0]}
      port: 80 # At every update, timestamp() will trigger a change and redeploy the container, even though nothing else has changed.
      registrySha256:
        fn::invoke:
          function: std:timestamp
          arguments: {}
          return: result
variables:
  main:
    fn::invoke:
      function: scaleway:registry:getNamespace
      arguments:
        name: my-registry
  mainGetImage:
    fn::invoke:
      function: scaleway:registry:getImage
      arguments:
        namespaceId: ${main.id}
        name: nginx-1-29-2-alpine

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along
// with the `registry_sha256` argument to trigger container redeployments when the image is updated.
// Ideally, you would create the namespace separately.
// For demonstration purposes, this example assumes the "nginx:latest" image is already available
// in the referenced namespace.
const main = new scaleway.registry.Namespace("main", {name: "some-unique-name"});
const nginx = scaleway.registry.getImageOutput({
    namespaceId: main.id,
    name: "nginx",
});
const nginxLatest = nginx.apply(nginx => scaleway.registry.getImageTagOutput({
    imageId: nginx.id,
    name: "latest",
}));
const mainNamespace = new scaleway.containers.Namespace("main", {name: "my-container-namespace"});
const mainContainer = new scaleway.containers.Container("main", {
    name: "nginx-latest",
    namespaceId: mainNamespace.id,
    image: pulumi.all([nginx, nginxLatest]).apply(([nginx, nginxLatest]) => `${mainScalewayRegistryNamespace.endpoint}/${nginx.name}:${nginxLatest.name}`),
    port: 80,
    registrySha256: nginxLatest.apply(nginxLatest => nginxLatest.digest),
});

import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

# When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along
# with the `registry_sha256` argument to trigger container redeployments when the image is updated.
# Ideally, you would create the namespace separately.
# For demonstration purposes, this example assumes the "nginx:latest" image is already available
# in the referenced namespace.
main = scaleway.registry.Namespace("main", name="some-unique-name")
nginx = scaleway.registry.get_image_output(namespace_id=main.id,
    name="nginx")
nginx_latest = nginx.apply(lambda nginx: scaleway.registry.get_image_tag_output(image_id=nginx.id,
    name="latest"))
main_namespace = scaleway.containers.Namespace("main", name="my-container-namespace")
main_container = scaleway.containers.Container("main",
    name="nginx-latest",
    namespace_id=main_namespace.id,
    image=pulumi.Output.all(
        nginx=nginx,
        nginx_latest=nginx_latest
).apply(lambda resolved_outputs: f"{main_scaleway_registry_namespace['endpoint']}/{nginx.name}:{nginx_latest.name}")
,
    port=80,
    registry_sha256=nginx_latest.digest)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/containers"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/registry"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along
		// with the `registry_sha256` argument to trigger container redeployments when the image is updated.
		// Ideally, you would create the namespace separately.
		// For demonstration purposes, this example assumes the "nginx:latest" image is already available
		// in the referenced namespace.
		main, err := registry.NewNamespace(ctx, "main", &registry.NamespaceArgs{
			Name: pulumi.String("some-unique-name"),
		})
		if err != nil {
			return err
		}
		nginx := registry.GetImageOutput(ctx, registry.GetImageOutputArgs{
			NamespaceId: main.ID(),
			Name:        pulumi.String("nginx"),
		}, nil)
		nginxLatest := nginx.ApplyT(func(nginx registry.GetImageResult) (registry.GetImageTagResult, error) {
			return registry.GetImageTagResult(interface{}(registry.GetImageTag(ctx, &registry.GetImageTagArgs{
				ImageId: nginx.Id,
				Name:    pulumi.StringRef(pulumi.StringRef("latest")),
			}, nil))), nil
		}).(registry.GetImageTagResultOutput)
		mainNamespace, err := containers.NewNamespace(ctx, "main", &containers.NamespaceArgs{
			Name: pulumi.String("my-container-namespace"),
		})
		if err != nil {
			return err
		}
		_, err = containers.NewContainer(ctx, "main", &containers.ContainerArgs{
			Name:        pulumi.String("nginx-latest"),
			NamespaceId: mainNamespace.ID(),
			Image: pulumi.All(nginx, nginxLatest).ApplyT(func(_args []interface{}) (string, error) {
				nginx := _args[0].(registry.GetImageResult)
				nginxLatest := _args[1].(registry.GetImageTagResult)
				return fmt.Sprintf("%v/%v:%v", mainScalewayRegistryNamespace.Endpoint, nginx.Name, nginxLatest.Name), nil
			}).(pulumi.StringOutput),
			Port: pulumi.Int(80),
			RegistrySha256: pulumi.String(nginxLatest.ApplyT(func(nginxLatest registry.GetImageTagResult) (*string, error) {
				return &nginxLatest.Digest, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along
    // with the `registry_sha256` argument to trigger container redeployments when the image is updated.
    // Ideally, you would create the namespace separately.
    // For demonstration purposes, this example assumes the "nginx:latest" image is already available
    // in the referenced namespace.
    var main = new Scaleway.Registry.Namespace("main", new()
    {
        Name = "some-unique-name",
    });

    var nginx = Scaleway.Registry.GetImage.Invoke(new()
    {
        NamespaceId = main.Id,
        Name = "nginx",
    });

    var nginxLatest = Scaleway.Registry.GetImageTag.Invoke(new()
    {
        ImageId = nginx.Apply(getImageResult => getImageResult.Id),
        Name = "latest",
    });

    var mainNamespace = new Scaleway.Containers.Namespace("main", new()
    {
        Name = "my-container-namespace",
    });

    var mainContainer = new Scaleway.Containers.Container("main", new()
    {
        Name = "nginx-latest",
        NamespaceId = mainNamespace.Id,
        Image = Output.Tuple(nginx, nginxLatest).Apply(values =>
        {
            var nginx = values.Item1;
            var nginxLatest = values.Item2;
            return $"{mainScalewayRegistryNamespace.Endpoint}/{nginx.Apply(getImageResult => getImageResult.Name)}:{nginxLatest.Apply(getImageTagResult => getImageTagResult.Name)}";
        }),
        Port = 80,
        RegistrySha256 = nginxLatest.Apply(getImageTagResult => getImageTagResult.Digest),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.registry.RegistryFunctions;
import com.pulumi.scaleway.registry.inputs.GetImageArgs;
import com.pulumi.scaleway.registry.inputs.GetImageTagArgs;
import com.pulumi.scaleway.containers.Container;
import com.pulumi.scaleway.containers.ContainerArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along
        // with the `registry_sha256` argument to trigger container redeployments when the image is updated.
        // Ideally, you would create the namespace separately.
        // For demonstration purposes, this example assumes the "nginx:latest" image is already available
        // in the referenced namespace.
        var main = new com.pulumi.scaleway.registry.Namespace("main", com.pulumi.scaleway.registry.NamespaceArgs.builder()
            .name("some-unique-name")
            .build());

        final var nginx = RegistryFunctions.getImage(GetImageArgs.builder()
            .namespaceId(main.id())
            .name("nginx")
            .build());

        final var nginxLatest = nginx.applyValue(_nginx -> RegistryFunctions.getImageTag(GetImageTagArgs.builder()
            .imageId(_nginx.id())
            .name("latest")
            .build()));

        var mainNamespace = new com.pulumi.scaleway.containers.Namespace("mainNamespace", com.pulumi.scaleway.containers.NamespaceArgs.builder()
            .name("my-container-namespace")
            .build());

        var mainContainer = new Container("mainContainer", ContainerArgs.builder()
            .name("nginx-latest")
            .namespaceId(mainNamespace.id())
            .image(Output.tuple(nginx, nginxLatest).applyValue(values -> {
                var nginx = values.t1;
                var nginxLatest = values.t2;
                return String.format("%s/%s:%s", mainScalewayRegistryNamespace.endpoint(),nginx.name(),nginxLatest.name());
            }))
            .port(80)
            .registrySha256(nginxLatest.applyValue(_nginxLatest -> _nginxLatest.digest()))
            .build());

    }
}

resources:
  # When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along
  # with the `registry_sha256` argument to trigger container redeployments when the image is updated.

  # Ideally, you would create the namespace separately.
  # For demonstration purposes, this example assumes the "nginx:latest" image is already available
  # in the referenced namespace.
  main:
    type: scaleway:registry:Namespace
    properties:
      name: some-unique-name
  mainNamespace:
    type: scaleway:containers:Namespace
    name: main
    properties:
      name: my-container-namespace
  mainContainer:
    type: scaleway:containers:Container
    name: main
    properties:
      name: nginx-latest
      namespaceId: ${mainNamespace.id}
      image: ${mainScalewayRegistryNamespace.endpoint}/${nginx.name}:${nginxLatest.name}
      port: 80 # Whenever the `latest` tag of the `nginx` image is updated, the `registry_sha256` will change, triggering a redeployment of the container with the new image.
      registrySha256: ${nginxLatest.digest}
variables:
  nginx:
    fn::invoke:
      function: scaleway:registry:getImage
      arguments:
        namespaceId: ${main.id}
        name: nginx
  nginxLatest:
    fn::invoke:
      function: scaleway:registry:getImageTag
      arguments:
        imageId: ${nginx.id}
        name: latest

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// Project to be referenced in the IAM policy
const _default = scaleway.account.getProject({
    name: "default",
});
// IAM resources
const containerAuth = new scaleway.iam.Application("container_auth", {name: "container-auth"});
const accessPrivateContainers = new scaleway.iam.Policy("access_private_containers", {
    applicationId: containerAuth.id,
    rules: [{
        projectIds: [_default.then(_default => _default.id)],
        permissionSetNames: ["ContainersPrivateAccess"],
    }],
});
const apiKey = new scaleway.iam.ApiKey("api_key", {applicationId: containerAuth.id});
// Container resources
const _private = new scaleway.containers.Namespace("private", {name: "private-container-namespace"});
const privateContainer = new scaleway.containers.Container("private", {
    namespaceId: _private.id,
    image: "rg.fr-par.scw.cloud/my-registry-ns/my-image:latest",
    privacy: "private",
});
export const secretKey = apiKey.secretKey;
export const containerEndpoint = privateContainer.domainName;

import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

# Project to be referenced in the IAM policy
default = scaleway.account.get_project(name="default")
# IAM resources
container_auth = scaleway.iam.Application("container_auth", name="container-auth")
access_private_containers = scaleway.iam.Policy("access_private_containers",
    application_id=container_auth.id,
    rules=[{
        "project_ids": [default.id],
        "permission_set_names": ["ContainersPrivateAccess"],
    }])
api_key = scaleway.iam.ApiKey("api_key", application_id=container_auth.id)
# Container resources
private = scaleway.containers.Namespace("private", name="private-container-namespace")
private_container = scaleway.containers.Container("private",
    namespace_id=private.id,
    image="rg.fr-par.scw.cloud/my-registry-ns/my-image:latest",
    privacy="private")
pulumi.export("secretKey", api_key.secret_key)
pulumi.export("containerEndpoint", private_container.domain_name)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/account"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/containers"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/iam"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Project to be referenced in the IAM policy
		_default, err := account.LookupProject(ctx, &account.LookupProjectArgs{
			Name: pulumi.StringRef("default"),
		}, nil)
		if err != nil {
			return err
		}
		// IAM resources
		containerAuth, err := iam.NewApplication(ctx, "container_auth", &iam.ApplicationArgs{
			Name: pulumi.String("container-auth"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewPolicy(ctx, "access_private_containers", &iam.PolicyArgs{
			ApplicationId: containerAuth.ID(),
			Rules: iam.PolicyRuleArray{
				&iam.PolicyRuleArgs{
					ProjectIds: pulumi.StringArray{
						pulumi.String(_default.Id),
					},
					PermissionSetNames: pulumi.StringArray{
						pulumi.String("ContainersPrivateAccess"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		apiKey, err := iam.NewApiKey(ctx, "api_key", &iam.ApiKeyArgs{
			ApplicationId: containerAuth.ID(),
		})
		if err != nil {
			return err
		}
		// Container resources
		private, err := containers.NewNamespace(ctx, "private", &containers.NamespaceArgs{
			Name: pulumi.String("private-container-namespace"),
		})
		if err != nil {
			return err
		}
		privateContainer, err := containers.NewContainer(ctx, "private", &containers.ContainerArgs{
			NamespaceId: private.ID(),
			Image:       pulumi.String("rg.fr-par.scw.cloud/my-registry-ns/my-image:latest"),
			Privacy:     pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		ctx.Export("secretKey", apiKey.SecretKey)
		ctx.Export("containerEndpoint", privateContainer.DomainName)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // Project to be referenced in the IAM policy
    var @default = Scaleway.Account.GetProject.Invoke(new()
    {
        Name = "default",
    });

    // IAM resources
    var containerAuth = new Scaleway.Iam.Application("container_auth", new()
    {
        Name = "container-auth",
    });

    var accessPrivateContainers = new Scaleway.Iam.Policy("access_private_containers", new()
    {
        ApplicationId = containerAuth.Id,
        Rules = new[]
        {
            new Scaleway.Iam.Inputs.PolicyRuleArgs
            {
                ProjectIds = new[]
                {
                    @default.Apply(@default => @default.Apply(getProjectResult => getProjectResult.Id)),
                },
                PermissionSetNames = new[]
                {
                    "ContainersPrivateAccess",
                },
            },
        },
    });

    var apiKey = new Scaleway.Iam.ApiKey("api_key", new()
    {
        ApplicationId = containerAuth.Id,
    });

    // Container resources
    var @private = new Scaleway.Containers.Namespace("private", new()
    {
        Name = "private-container-namespace",
    });

    var privateContainer = new Scaleway.Containers.Container("private", new()
    {
        NamespaceId = @private.Id,
        Image = "rg.fr-par.scw.cloud/my-registry-ns/my-image:latest",
        Privacy = "private",
    });

    return new Dictionary<string, object?>
    {
        ["secretKey"] = apiKey.SecretKey,
        ["containerEndpoint"] = privateContainer.DomainName,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.account.AccountFunctions;
import com.pulumi.scaleway.account.inputs.GetProjectArgs;
import com.pulumi.scaleway.iam.Application;
import com.pulumi.scaleway.iam.ApplicationArgs;
import com.pulumi.scaleway.iam.Policy;
import com.pulumi.scaleway.iam.PolicyArgs;
import com.pulumi.scaleway.iam.inputs.PolicyRuleArgs;
import com.pulumi.scaleway.iam.ApiKey;
import com.pulumi.scaleway.iam.ApiKeyArgs;
import com.pulumi.scaleway.containers.Namespace;
import com.pulumi.scaleway.containers.NamespaceArgs;
import com.pulumi.scaleway.containers.Container;
import com.pulumi.scaleway.containers.ContainerArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // Project to be referenced in the IAM policy
        final var default = AccountFunctions.getProject(GetProjectArgs.builder()
            .name("default")
            .build());

        // IAM resources
        var containerAuth = new Application("containerAuth", ApplicationArgs.builder()
            .name("container-auth")
            .build());

        var accessPrivateContainers = new Policy("accessPrivateContainers", PolicyArgs.builder()
            .applicationId(containerAuth.id())
            .rules(PolicyRuleArgs.builder()
                .projectIds(default_.id())
                .permissionSetNames("ContainersPrivateAccess")
                .build())
            .build());

        var apiKey = new ApiKey("apiKey", ApiKeyArgs.builder()
            .applicationId(containerAuth.id())
            .build());

        // Container resources
        var private_ = new Namespace("private", NamespaceArgs.builder()
            .name("private-container-namespace")
            .build());

        var privateContainer = new Container("privateContainer", ContainerArgs.builder()
            .namespaceId(private_.id())
            .image("rg.fr-par.scw.cloud/my-registry-ns/my-image:latest")
            .privacy("private")
            .build());

        ctx.export("secretKey", apiKey.secretKey());
        ctx.export("containerEndpoint", privateContainer.domainName());
    }
}

resources:
  # IAM resources
  containerAuth:
    type: scaleway:iam:Application
    name: container_auth
    properties:
      name: container-auth
  accessPrivateContainers:
    type: scaleway:iam:Policy
    name: access_private_containers
    properties:
      applicationId: ${containerAuth.id}
      rules:
        - projectIds:
            - ${default.id}
          permissionSetNames:
            - ContainersPrivateAccess
  apiKey:
    type: scaleway:iam:ApiKey
    name: api_key
    properties:
      applicationId: ${containerAuth.id}
  # Container resources
  private:
    type: scaleway:containers:Namespace
    properties:
      name: private-container-namespace
  privateContainer:
    type: scaleway:containers:Container
    name: private
    properties:
      namespaceId: ${private.id}
      image: rg.fr-par.scw.cloud/my-registry-ns/my-image:latest
      privacy: private
variables:
  # Project to be referenced in the IAM policy
  default:
    fn::invoke:
      function: scaleway:account:getProject
      arguments:
        name: default
outputs:
  # Output the secret key and the container's endpoint for the curl command
  secretKey: ${apiKey.secretKey}
  containerEndpoint: ${privateContainer.domainName}