tailscale.Acl

import * as pulumi from "@pulumi/pulumi";
import * as tailscale from "@pulumi/tailscale";

const asJson = new tailscale.Acl("as_json", {acl: JSON.stringify({
    acls: [{
        action: "accept",
        users: ["*"],
        ports: ["*:*"],
    }],
})});
const asHujson = new tailscale.Acl("as_hujson", {acl: `  {
    // Comments in HuJSON policy are preserved when the policy is applied.
    "acls": [
      {
        // Allow all users access to all ports.
        action = "accept",
        users  = ["*"],
        ports  = ["*:*"],
      },
    ],
  }
`});

import pulumi
import json
import pulumi_tailscale as tailscale

as_json = tailscale.Acl("as_json", acl=json.dumps({
    "acls": [{
        "action": "accept",
        "users": ["*"],
        "ports": ["*:*"],
    }],
}))
as_hujson = tailscale.Acl("as_hujson", acl="""  {
    // Comments in HuJSON policy are preserved when the policy is applied.
    "acls": [
      {
        // Allow all users access to all ports.
        action = "accept",
        users  = ["*"],
        ports  = ["*:*"],
      },
    ],
  }
""")

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-tailscale/sdk/go/tailscale"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"acls": []map[string]interface{}{
				map[string]interface{}{
					"action": "accept",
					"users": []string{
						"*",
					},
					"ports": []string{
						"*:*",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = tailscale.NewAcl(ctx, "as_json", &tailscale.AclArgs{
			Acl: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_, err = tailscale.NewAcl(ctx, "as_hujson", &tailscale.AclArgs{
			Acl: pulumi.String(`  {
    // Comments in HuJSON policy are preserved when the policy is applied.
    "acls": [
      {
        // Allow all users access to all ports.
        action = "accept",
        users  = ["*"],
        ports  = ["*:*"],
      },
    ],
  }
`),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Tailscale = Pulumi.Tailscale;

return await Deployment.RunAsync(() => 
{
    var asJson = new Tailscale.Acl("as_json", new()
    {
        AclJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["acls"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["action"] = "accept",
                    ["users"] = new[]
                    {
                        "*",
                    },
                    ["ports"] = new[]
                    {
                        "*:*",
                    },
                },
            },
        }),
    });

    var asHujson = new Tailscale.Acl("as_hujson", new()
    {
        AclJson = @"  {
    // Comments in HuJSON policy are preserved when the policy is applied.
    ""acls"": [
      {
        // Allow all users access to all ports.
        action = ""accept"",
        users  = [""*""],
        ports  = [""*:*""],
      },
    ],
  }
",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tailscale.Acl;
import com.pulumi.tailscale.AclArgs;
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 asJson = new Acl("asJson", AclArgs.builder()
            .acl(serializeJson(
                jsonObject(
                    jsonProperty("acls", jsonArray(jsonObject(
                        jsonProperty("action", "accept"),
                        jsonProperty("users", jsonArray("*")),
                        jsonProperty("ports", jsonArray("*:*"))
                    )))
                )))
            .build());

        var asHujson = new Acl("asHujson", AclArgs.builder()
            .acl("""
  {
    // Comments in HuJSON policy are preserved when the policy is applied.
    "acls": [
      {
        // Allow all users access to all ports.
        action = "accept",
        users  = ["*"],
        ports  = ["*:*"],
      },
    ],
  }
            """)
            .build());

    }
}

resources:
  asJson:
    type: tailscale:Acl
    name: as_json
    properties:
      acl:
        fn::toJSON:
          acls:
            - action: accept
              users:
                - '*'
              ports:
                - '*:*'
  asHujson:
    type: tailscale:Acl
    name: as_hujson
    properties:
      acl: |2
          {
            // Comments in HuJSON policy are preserved when the policy is applied.
            "acls": [
              {
                // Allow all users access to all ports.
                action = "accept",
                users  = ["*"],
                ports  = ["*:*"],
              },
            ],
          }

var aclResource = new Tailscale.Acl("aclResource", new()
{
    AclJson = "string",
    OverwriteExistingContent = false,
});

example, err := tailscale.NewAcl(ctx, "aclResource", &tailscale.AclArgs{
	Acl:                      pulumi.String("string"),
	OverwriteExistingContent: pulumi.Bool(false),
})

var aclResource = new Acl("aclResource", AclArgs.builder()
    .acl("string")
    .overwriteExistingContent(false)
    .build());

acl_resource = tailscale.Acl("aclResource",
    acl="string",
    overwrite_existing_content=False)

const aclResource = new tailscale.Acl("aclResource", {
    acl: "string",
    overwriteExistingContent: false,
});

type: tailscale:Acl
properties:
    acl: string
    overwriteExistingContent: false