scaleway.FunctionCron

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Scaleway = Lbrlabs.PulumiPackage.Scaleway;

return await Deployment.RunAsync(() => 
{
    var mainFunctionNamespace = new Scaleway.FunctionNamespace("mainFunctionNamespace");

    var mainFunction = new Scaleway.Function("mainFunction", new()
    {
        NamespaceId = mainFunctionNamespace.Id,
        Runtime = "node14",
        Privacy = "private",
        Handler = "handler.handle",
    });

    var mainFunctionCron = new Scaleway.FunctionCron("mainFunctionCron", new()
    {
        FunctionId = mainFunction.Id,
        Schedule = "0 0 * * *",
        Args = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["test"] = "scw",
        }),
    });

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

});

package main

import (
	"encoding/json"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		mainFunctionNamespace, err := scaleway.NewFunctionNamespace(ctx, "mainFunctionNamespace", nil)
		if err != nil {
			return err
		}
		mainFunction, err := scaleway.NewFunction(ctx, "mainFunction", &scaleway.FunctionArgs{
			NamespaceId: mainFunctionNamespace.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 = scaleway.NewFunctionCron(ctx, "mainFunctionCron", &scaleway.FunctionCronArgs{
			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 = scaleway.NewFunctionCron(ctx, "func", &scaleway.FunctionCronArgs{
			FunctionId: mainFunction.ID(),
			Schedule:   pulumi.String("0 1 * * *"),
			Args:       pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.FunctionNamespace;
import com.pulumi.scaleway.Function;
import com.pulumi.scaleway.FunctionArgs;
import com.pulumi.scaleway.FunctionCron;
import com.pulumi.scaleway.FunctionCronArgs;
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 mainFunctionNamespace = new FunctionNamespace("mainFunctionNamespace");

        var mainFunction = new Function("mainFunction", FunctionArgs.builder()        
            .namespaceId(mainFunctionNamespace.id())
            .runtime("node14")
            .privacy("private")
            .handler("handler.handle")
            .build());

        var mainFunctionCron = new FunctionCron("mainFunctionCron", FunctionCronArgs.builder()        
            .functionId(mainFunction.id())
            .schedule("0 0 * * *")
            .args(serializeJson(
                jsonObject(
                    jsonProperty("test", "scw")
                )))
            .build());

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

    }
}

import pulumi
import json
import lbrlabs_pulumi_scaleway as scaleway

main_function_namespace = scaleway.FunctionNamespace("mainFunctionNamespace")
main_function = scaleway.Function("mainFunction",
    namespace_id=main_function_namespace.id,
    runtime="node14",
    privacy="private",
    handler="handler.handle")
main_function_cron = scaleway.FunctionCron("mainFunctionCron",
    function_id=main_function.id,
    schedule="0 0 * * *",
    args=json.dumps({
        "test": "scw",
    }))
func = scaleway.FunctionCron("func",
    function_id=main_function.id,
    schedule="0 1 * * *",
    args=json.dumps({
        "my_var": "terraform",
    }))

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@lbrlabs/pulumi-scaleway";

const mainFunctionNamespace = new scaleway.FunctionNamespace("mainFunctionNamespace", {});
const mainFunction = new scaleway.Function("mainFunction", {
    namespaceId: mainFunctionNamespace.id,
    runtime: "node14",
    privacy: "private",
    handler: "handler.handle",
});
const mainFunctionCron = new scaleway.FunctionCron("mainFunctionCron", {
    functionId: mainFunction.id,
    schedule: "0 0 * * *",
    args: JSON.stringify({
        test: "scw",
    }),
});
const func = new scaleway.FunctionCron("func", {
    functionId: mainFunction.id,
    schedule: "0 1 * * *",
    args: JSON.stringify({
        my_var: "terraform",
    }),
});

resources:
  mainFunctionNamespace:
    type: scaleway:FunctionNamespace
  mainFunction:
    type: scaleway:Function
    properties:
      namespaceId: ${mainFunctionNamespace.id}
      runtime: node14
      privacy: private
      handler: handler.handle
  mainFunctionCron:
    type: scaleway:FunctionCron
    properties:
      functionId: ${mainFunction.id}
      schedule: 0 0 * * *
      args:
        fn::toJSON:
          test: scw
  func:
    type: scaleway:FunctionCron
    properties:
      functionId: ${mainFunction.id}
      schedule: 0 1 * * *
      args:
        fn::toJSON:
          my_var: terraform