scaleway.ContainerCron

import pulumi
import json
import pulumiverse_scaleway as scaleway

main = scaleway.containers.Namespace("main")
main_container = scaleway.containers.Container("main",
    name="my-container-with-cron-tf",
    namespace_id=main.id)
main_cron = scaleway.containers.Cron("main",
    container_id=main_container.id,
    name="my-cron-name",
    schedule="5 4 1 * *",
    args=json.dumps({
        "address": {
            "city": "Paris",
            "country": "FR",
        },
        "age": 23,
        "firstName": "John",
        "isAlive": True,
        "lastName": "Smith",
    }))

package main

import (
	"encoding/json"

	"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
		}
		mainContainer, err := containers.NewContainer(ctx, "main", &containers.ContainerArgs{
			Name:        pulumi.String("my-container-with-cron-tf"),
			NamespaceId: main.ID(),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"address": map[string]interface{}{
				"city":    "Paris",
				"country": "FR",
			},
			"age":       23,
			"firstName": "John",
			"isAlive":   true,
			"lastName":  "Smith",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = containers.NewCron(ctx, "main", &containers.CronArgs{
			ContainerId: mainContainer.ID(),
			Name:        pulumi.String("my-cron-name"),
			Schedule:    pulumi.String("5 4 1 * *"),
			Args:        pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
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-with-cron-tf",
        NamespaceId = main.Id,
    });

    var mainCron = new Scaleway.Containers.Cron("main", new()
    {
        ContainerId = mainContainer.Id,
        Name = "my-cron-name",
        Schedule = "5 4 1 * *",
        Args = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["address"] = new Dictionary<string, object?>
            {
                ["city"] = "Paris",
                ["country"] = "FR",
            },
            ["age"] = 23,
            ["firstName"] = "John",
            ["isAlive"] = true,
            ["lastName"] = "Smith",
        }),
    });

});

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 com.pulumi.scaleway.containers.Cron;
import com.pulumi.scaleway.containers.CronArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
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-with-cron-tf")
            .namespaceId(main.id())
            .build());

        var mainCron = new Cron("mainCron", CronArgs.builder()
            .containerId(mainContainer.id())
            .name("my-cron-name")
            .schedule("5 4 1 * *")
            .args(serializeJson(
                jsonObject(
                    jsonProperty("address", jsonObject(
                        jsonProperty("city", "Paris"),
                        jsonProperty("country", "FR")
                    )),
                    jsonProperty("age", 23),
                    jsonProperty("firstName", "John"),
                    jsonProperty("isAlive", true),
                    jsonProperty("lastName", "Smith")
                )))
            .build());

    }
}

resources:
  main:
    type: scaleway:containers:Namespace
  mainContainer:
    type: scaleway:containers:Container
    name: main
    properties:
      name: my-container-with-cron-tf
      namespaceId: ${main.id}
  mainCron:
    type: scaleway:containers:Cron
    name: main
    properties:
      containerId: ${mainContainer.id}
      name: my-cron-name
      schedule: 5 4 1 * *
      args:
        fn::toJSON:
          address:
            city: Paris
            country: FR
          age: 23
          firstName: John
          isAlive: true
          lastName: Smith