keycloak.UserRoles

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

return await Deployment.RunAsync(() => 
{
    var realm = new Keycloak.Realm("realm", new()
    {
        RealmName = "my-realm",
        Enabled = true,
    });

    var realmRole = new Keycloak.Role("realmRole", new()
    {
        RealmId = realm.Id,
        Description = "My Realm Role",
    });

    var client = new Keycloak.OpenId.Client("client", new()
    {
        RealmId = realm.Id,
        ClientId = "client",
        Enabled = true,
        AccessType = "BEARER-ONLY",
    });

    var clientRole = new Keycloak.Role("clientRole", new()
    {
        RealmId = realm.Id,
        ClientId = keycloak_client.Client.Id,
        Description = "My Client Role",
    });

    var user = new Keycloak.User("user", new()
    {
        RealmId = realm.Id,
        Username = "bob",
        Enabled = true,
        Email = "bob@domain.com",
        FirstName = "Bob",
        LastName = "Bobson",
    });

    var userRoles = new Keycloak.UserRoles("userRoles", new()
    {
        RealmId = realm.Id,
        UserId = user.Id,
        RoleIds = new[]
        {
            realmRole.Id,
            clientRole.Id,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-keycloak/sdk/v5/go/keycloak"
	"github.com/pulumi/pulumi-keycloak/sdk/v5/go/keycloak/openid"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		realm, err := keycloak.NewRealm(ctx, "realm", &keycloak.RealmArgs{
			Realm:   pulumi.String("my-realm"),
			Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		realmRole, err := keycloak.NewRole(ctx, "realmRole", &keycloak.RoleArgs{
			RealmId:     realm.ID(),
			Description: pulumi.String("My Realm Role"),
		})
		if err != nil {
			return err
		}
		_, err = openid.NewClient(ctx, "client", &openid.ClientArgs{
			RealmId:    realm.ID(),
			ClientId:   pulumi.String("client"),
			Enabled:    pulumi.Bool(true),
			AccessType: pulumi.String("BEARER-ONLY"),
		})
		if err != nil {
			return err
		}
		clientRole, err := keycloak.NewRole(ctx, "clientRole", &keycloak.RoleArgs{
			RealmId:     realm.ID(),
			ClientId:    pulumi.Any(keycloak_client.Client.Id),
			Description: pulumi.String("My Client Role"),
		})
		if err != nil {
			return err
		}
		user, err := keycloak.NewUser(ctx, "user", &keycloak.UserArgs{
			RealmId:   realm.ID(),
			Username:  pulumi.String("bob"),
			Enabled:   pulumi.Bool(true),
			Email:     pulumi.String("bob@domain.com"),
			FirstName: pulumi.String("Bob"),
			LastName:  pulumi.String("Bobson"),
		})
		if err != nil {
			return err
		}
		_, err = keycloak.NewUserRoles(ctx, "userRoles", &keycloak.UserRolesArgs{
			RealmId: realm.ID(),
			UserId:  user.ID(),
			RoleIds: pulumi.StringArray{
				realmRole.ID(),
				clientRole.ID(),
			},
		})
		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.keycloak.Realm;
import com.pulumi.keycloak.RealmArgs;
import com.pulumi.keycloak.Role;
import com.pulumi.keycloak.RoleArgs;
import com.pulumi.keycloak.openid.Client;
import com.pulumi.keycloak.openid.ClientArgs;
import com.pulumi.keycloak.User;
import com.pulumi.keycloak.UserArgs;
import com.pulumi.keycloak.UserRoles;
import com.pulumi.keycloak.UserRolesArgs;
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 realm = new Realm("realm", RealmArgs.builder()        
            .realm("my-realm")
            .enabled(true)
            .build());

        var realmRole = new Role("realmRole", RoleArgs.builder()        
            .realmId(realm.id())
            .description("My Realm Role")
            .build());

        var client = new Client("client", ClientArgs.builder()        
            .realmId(realm.id())
            .clientId("client")
            .enabled(true)
            .accessType("BEARER-ONLY")
            .build());

        var clientRole = new Role("clientRole", RoleArgs.builder()        
            .realmId(realm.id())
            .clientId(keycloak_client.client().id())
            .description("My Client Role")
            .build());

        var user = new User("user", UserArgs.builder()        
            .realmId(realm.id())
            .username("bob")
            .enabled(true)
            .email("bob@domain.com")
            .firstName("Bob")
            .lastName("Bobson")
            .build());

        var userRoles = new UserRoles("userRoles", UserRolesArgs.builder()        
            .realmId(realm.id())
            .userId(user.id())
            .roleIds(            
                realmRole.id(),
                clientRole.id())
            .build());

    }
}

import pulumi
import pulumi_keycloak as keycloak

realm = keycloak.Realm("realm",
    realm="my-realm",
    enabled=True)
realm_role = keycloak.Role("realmRole",
    realm_id=realm.id,
    description="My Realm Role")
client = keycloak.openid.Client("client",
    realm_id=realm.id,
    client_id="client",
    enabled=True,
    access_type="BEARER-ONLY")
client_role = keycloak.Role("clientRole",
    realm_id=realm.id,
    client_id=keycloak_client["client"]["id"],
    description="My Client Role")
user = keycloak.User("user",
    realm_id=realm.id,
    username="bob",
    enabled=True,
    email="bob@domain.com",
    first_name="Bob",
    last_name="Bobson")
user_roles = keycloak.UserRoles("userRoles",
    realm_id=realm.id,
    user_id=user.id,
    role_ids=[
        realm_role.id,
        client_role.id,
    ])

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

const realm = new keycloak.Realm("realm", {
    realm: "my-realm",
    enabled: true,
});
const realmRole = new keycloak.Role("realmRole", {
    realmId: realm.id,
    description: "My Realm Role",
});
const client = new keycloak.openid.Client("client", {
    realmId: realm.id,
    clientId: "client",
    enabled: true,
    accessType: "BEARER-ONLY",
});
const clientRole = new keycloak.Role("clientRole", {
    realmId: realm.id,
    clientId: keycloak_client.client.id,
    description: "My Client Role",
});
const user = new keycloak.User("user", {
    realmId: realm.id,
    username: "bob",
    enabled: true,
    email: "bob@domain.com",
    firstName: "Bob",
    lastName: "Bobson",
});
const userRoles = new keycloak.UserRoles("userRoles", {
    realmId: realm.id,
    userId: user.id,
    roleIds: [
        realmRole.id,
        clientRole.id,
    ],
});

resources:
  realm:
    type: keycloak:Realm
    properties:
      realm: my-realm
      enabled: true
  realmRole:
    type: keycloak:Role
    properties:
      realmId: ${realm.id}
      description: My Realm Role
  client:
    type: keycloak:openid:Client
    properties:
      realmId: ${realm.id}
      clientId: client
      enabled: true
      accessType: BEARER-ONLY
  clientRole:
    type: keycloak:Role
    properties:
      realmId: ${realm.id}
      clientId: ${keycloak_client.client.id}
      description: My Client Role
  user:
    type: keycloak:User
    properties:
      realmId: ${realm.id}
      username: bob
      enabled: true
      email: bob@domain.com
      firstName: Bob
      lastName: Bobson
  userRoles:
    type: keycloak:UserRoles
    properties:
      realmId: ${realm.id}
      userId: ${user.id}
      roleIds:
        - ${realmRole.id}
        - ${clientRole.id}