scaleway.IamGroupMembership

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const group = new scaleway.IamGroup("group", {externalMembership: true});
const app = new scaleway.IamApplication("app", {});
const member = new scaleway.IamGroupMembership("member", {
    groupId: group.id,
    applicationId: app.id,
});

import pulumi
import pulumiverse_scaleway as scaleway

group = scaleway.IamGroup("group", external_membership=True)
app = scaleway.IamApplication("app")
member = scaleway.IamGroupMembership("member",
    group_id=group.id,
    application_id=app.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		group, err := scaleway.NewIamGroup(ctx, "group", &scaleway.IamGroupArgs{
			ExternalMembership: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		app, err := scaleway.NewIamApplication(ctx, "app", nil)
		if err != nil {
			return err
		}
		_, err = scaleway.NewIamGroupMembership(ctx, "member", &scaleway.IamGroupMembershipArgs{
			GroupId:       group.ID(),
			ApplicationId: app.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var @group = new Scaleway.IamGroup("group", new()
    {
        ExternalMembership = true,
    });

    var app = new Scaleway.IamApplication("app");

    var member = new Scaleway.IamGroupMembership("member", new()
    {
        GroupId = @group.Id,
        ApplicationId = app.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.IamGroup;
import com.pulumi.scaleway.IamGroupArgs;
import com.pulumi.scaleway.IamApplication;
import com.pulumi.scaleway.IamGroupMembership;
import com.pulumi.scaleway.IamGroupMembershipArgs;
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 group = new IamGroup("group", IamGroupArgs.builder()        
            .externalMembership(true)
            .build());

        var app = new IamApplication("app");

        var member = new IamGroupMembership("member", IamGroupMembershipArgs.builder()        
            .groupId(group.id())
            .applicationId(app.id())
            .build());

    }
}

resources:
  group:
    type: scaleway:IamGroup
    properties:
      externalMembership: true
  app:
    type: scaleway:IamApplication
  member:
    type: scaleway:IamGroupMembership
    properties:
      groupId: ${group.id}
      applicationId: ${app.id}

var iamGroupMembershipResource = new Scaleway.IamGroupMembership("iamGroupMembershipResource", new()
{
    GroupId = "string",
    ApplicationId = "string",
    UserId = "string",
});

example, err := scaleway.NewIamGroupMembership(ctx, "iamGroupMembershipResource", &scaleway.IamGroupMembershipArgs{
	GroupId:       pulumi.String("string"),
	ApplicationId: pulumi.String("string"),
	UserId:        pulumi.String("string"),
})

var iamGroupMembershipResource = new IamGroupMembership("iamGroupMembershipResource", IamGroupMembershipArgs.builder()        
    .groupId("string")
    .applicationId("string")
    .userId("string")
    .build());

iam_group_membership_resource = scaleway.IamGroupMembership("iamGroupMembershipResource",
    group_id="string",
    application_id="string",
    user_id="string")

const iamGroupMembershipResource = new scaleway.IamGroupMembership("iamGroupMembershipResource", {
    groupId: "string",
    applicationId: "string",
    userId: "string",
});

type: scaleway:IamGroupMembership
properties:
    applicationId: string
    groupId: string
    userId: string