etcd.User

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

const summaryReader = new etcd.Role("summaryReader", {permissions: [{
    permission: "read",
    key: "/summary.txt",
    rangeEnd: "/summary.txt",
}]});
const bob = new etcd.User("bob", {
    username: "bob",
    password: "1234",
    roles: [summaryReader.name],
});

import pulumi
import pulumi_etcd as etcd

summary_reader = etcd.Role("summaryReader", permissions=[{
    "permission": "read",
    "key": "/summary.txt",
    "range_end": "/summary.txt",
}])
bob = etcd.User("bob",
    username="bob",
    password="1234",
    roles=[summary_reader.name])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/etcd/etcd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		summaryReader, err := etcd.NewRole(ctx, "summaryReader", &etcd.RoleArgs{
			Permissions: etcd.RolePermissionArray{
				&etcd.RolePermissionArgs{
					Permission: pulumi.String("read"),
					Key:        pulumi.String("/summary.txt"),
					RangeEnd:   pulumi.String("/summary.txt"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = etcd.NewUser(ctx, "bob", &etcd.UserArgs{
			Username: pulumi.String("bob"),
			Password: pulumi.String("1234"),
			Roles: pulumi.StringArray{
				summaryReader.Name,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Etcd = Pulumi.Etcd;

return await Deployment.RunAsync(() => 
{
    var summaryReader = new Etcd.Role("summaryReader", new()
    {
        Permissions = new[]
        {
            new Etcd.Inputs.RolePermissionArgs
            {
                Permission = "read",
                Key = "/summary.txt",
                RangeEnd = "/summary.txt",
            },
        },
    });

    var bob = new Etcd.User("bob", new()
    {
        Username = "bob",
        Password = "1234",
        Roles = new[]
        {
            summaryReader.Name,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.etcd.Role;
import com.pulumi.etcd.RoleArgs;
import com.pulumi.etcd.inputs.RolePermissionArgs;
import com.pulumi.etcd.User;
import com.pulumi.etcd.UserArgs;
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 summaryReader = new Role("summaryReader", RoleArgs.builder()
            .permissions(RolePermissionArgs.builder()
                .permission("read")
                .key("/summary.txt")
                .rangeEnd("/summary.txt")
                .build())
            .build());

        var bob = new User("bob", UserArgs.builder()
            .username("bob")
            .password("1234")
            .roles(summaryReader.name())
            .build());

    }
}

resources:
  summaryReader:
    type: etcd:Role
    properties:
      permissions:
        - permission: read
          key: /summary.txt
          rangeEnd: /summary.txt
  bob:
    type: etcd:User
    properties:
      username: bob
      password: '1234'
      roles:
        - ${summaryReader.name}

var userResource = new Etcd.User("userResource", new()
{
    Username = "string",
    Password = "string",
    Roles = new[]
    {
        "string",
    },
    UserId = "string",
});

example, err := etcd.NewUser(ctx, "userResource", &etcd.UserArgs{
	Username: pulumi.String("string"),
	Password: pulumi.String("string"),
	Roles: pulumi.StringArray{
		pulumi.String("string"),
	},
	UserId: pulumi.String("string"),
})

var userResource = new User("userResource", UserArgs.builder()
    .username("string")
    .password("string")
    .roles("string")
    .userId("string")
    .build());

user_resource = etcd.User("userResource",
    username="string",
    password="string",
    roles=["string"],
    user_id="string")

const userResource = new etcd.User("userResource", {
    username: "string",
    password: "string",
    roles: ["string"],
    userId: "string",
});

type: etcd:User
properties:
    password: string
    roles:
        - string
    userId: string
    username: string