scaleway.FunctionCron

import pulumi
import json
import pulumiverse_scaleway as scaleway

main = scaleway.functions.Namespace("main", name="test-cron")
main_function = scaleway.functions.Function("main",
    name="test-cron",
    namespace_id=main.id,
    runtime="node14",
    privacy="private",
    handler="handler.handle")
main_cron = scaleway.functions.Cron("main",
    name="test-cron",
    function_id=main_function.id,
    schedule="0 0 * * *",
    args=json.dumps({
        "test": "scw",
    }))
func = scaleway.functions.Cron("func",
    function_id=main_function.id,
    schedule="0 1 * * *",
    args=json.dumps({
        "my_var": "terraform",
    }))

package main

import (
	"encoding/json"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := functions.NewNamespace(ctx, "main", &functions.NamespaceArgs{
			Name: pulumi.String("test-cron"),
		})
		if err != nil {
			return err
		}
		mainFunction, err := functions.NewFunction(ctx, "main", &functions.FunctionArgs{
			Name:        pulumi.String("test-cron"),
			NamespaceId: main.ID(),
			Runtime:     pulumi.String("node14"),
			Privacy:     pulumi.String("private"),
			Handler:     pulumi.String("handler.handle"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"test": "scw",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = functions.NewCron(ctx, "main", &functions.CronArgs{
			Name:       pulumi.String("test-cron"),
			FunctionId: mainFunction.ID(),
			Schedule:   pulumi.String("0 0 * * *"),
			Args:       pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"my_var": "terraform",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = functions.NewCron(ctx, "func", &functions.CronArgs{
			FunctionId: mainFunction.ID(),
			Schedule:   pulumi.String("0 1 * * *"),
			Args:       pulumi.String(json1),
		})
		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.Functions.Namespace("main", new()
    {
        Name = "test-cron",
    });

    var mainFunction = new Scaleway.Functions.Function("main", new()
    {
        Name = "test-cron",
        NamespaceId = main.Id,
        Runtime = "node14",
        Privacy = "private",
        Handler = "handler.handle",
    });

    var mainCron = new Scaleway.Functions.Cron("main", new()
    {
        Name = "test-cron",
        FunctionId = mainFunction.Id,
        Schedule = "0 0 * * *",
        Args = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["test"] = "scw",
        }),
    });

    var func = new Scaleway.Functions.Cron("func", new()
    {
        FunctionId = mainFunction.Id,
        Schedule = "0 1 * * *",
        Args = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["my_var"] = "terraform",
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.functions.Namespace;
import com.pulumi.scaleway.functions.NamespaceArgs;
import com.pulumi.scaleway.functions.Function;
import com.pulumi.scaleway.functions.FunctionArgs;
import com.pulumi.scaleway.functions.Cron;
import com.pulumi.scaleway.functions.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", NamespaceArgs.builder()
            .name("test-cron")
            .build());

        var mainFunction = new Function("mainFunction", FunctionArgs.builder()
            .name("test-cron")
            .namespaceId(main.id())
            .runtime("node14")
            .privacy("private")
            .handler("handler.handle")
            .build());

        var mainCron = new Cron("mainCron", CronArgs.builder()
            .name("test-cron")
            .functionId(mainFunction.id())
            .schedule("0 0 * * *")
            .args(serializeJson(
                jsonObject(
                    jsonProperty("test", "scw")
                )))
            .build());

        var func = new Cron("func", CronArgs.builder()
            .functionId(mainFunction.id())
            .schedule("0 1 * * *")
            .args(serializeJson(
                jsonObject(
                    jsonProperty("my_var", "terraform")
                )))
            .build());

    }
}

resources:
  main:
    type: scaleway:functions:Namespace
    properties:
      name: test-cron
  mainFunction:
    type: scaleway:functions:Function
    name: main
    properties:
      name: test-cron
      namespaceId: ${main.id}
      runtime: node14
      privacy: private
      handler: handler.handle
  mainCron:
    type: scaleway:functions:Cron
    name: main
    properties:
      name: test-cron
      functionId: ${mainFunction.id}
      schedule: 0 0 * * *
      args:
        fn::toJSON:
          test: scw
  func:
    type: scaleway:functions:Cron
    properties:
      functionId: ${mainFunction.id}
      schedule: 0 1 * * *
      args:
        fn::toJSON:
          my_var: terraform