rabbitmq.Binding

using System.Collections.Generic;
using Pulumi;
using RabbitMQ = Pulumi.RabbitMQ;

return await Deployment.RunAsync(() => 
{
    var testVHost = new RabbitMQ.VHost("testVHost");

    var guest = new RabbitMQ.Permissions("guest", new()
    {
        PermissionDetails = new RabbitMQ.Inputs.PermissionsPermissionsArgs
        {
            Configure = ".*",
            Read = ".*",
            Write = ".*",
        },
        User = "guest",
        Vhost = testVHost.Name,
    });

    var testExchange = new RabbitMQ.Exchange("testExchange", new()
    {
        Settings = new RabbitMQ.Inputs.ExchangeSettingsArgs
        {
            AutoDelete = true,
            Durable = false,
            Type = "fanout",
        },
        Vhost = guest.Vhost,
    });

    var testQueue = new RabbitMQ.Queue("testQueue", new()
    {
        Settings = new RabbitMQ.Inputs.QueueSettingsArgs
        {
            AutoDelete = false,
            Durable = true,
        },
        Vhost = guest.Vhost,
    });

    var testBinding = new RabbitMQ.Binding("testBinding", new()
    {
        Destination = testQueue.Name,
        DestinationType = "queue",
        RoutingKey = "#",
        Source = testExchange.Name,
        Vhost = testVHost.Name,
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testVHost, err := rabbitmq.NewVHost(ctx, "testVHost", nil)
		if err != nil {
			return err
		}
		guest, err := rabbitmq.NewPermissions(ctx, "guest", &rabbitmq.PermissionsArgs{
			Permissions: &rabbitmq.PermissionsPermissionsArgs{
				Configure: pulumi.String(".*"),
				Read:      pulumi.String(".*"),
				Write:     pulumi.String(".*"),
			},
			User:  pulumi.String("guest"),
			Vhost: testVHost.Name,
		})
		if err != nil {
			return err
		}
		testExchange, err := rabbitmq.NewExchange(ctx, "testExchange", &rabbitmq.ExchangeArgs{
			Settings: &rabbitmq.ExchangeSettingsArgs{
				AutoDelete: pulumi.Bool(true),
				Durable:    pulumi.Bool(false),
				Type:       pulumi.String("fanout"),
			},
			Vhost: guest.Vhost,
		})
		if err != nil {
			return err
		}
		testQueue, err := rabbitmq.NewQueue(ctx, "testQueue", &rabbitmq.QueueArgs{
			Settings: &rabbitmq.QueueSettingsArgs{
				AutoDelete: pulumi.Bool(false),
				Durable:    pulumi.Bool(true),
			},
			Vhost: guest.Vhost,
		})
		if err != nil {
			return err
		}
		_, err = rabbitmq.NewBinding(ctx, "testBinding", &rabbitmq.BindingArgs{
			Destination:     testQueue.Name,
			DestinationType: pulumi.String("queue"),
			RoutingKey:      pulumi.String("#"),
			Source:          testExchange.Name,
			Vhost:           testVHost.Name,
		})
		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.rabbitmq.VHost;
import com.pulumi.rabbitmq.Permissions;
import com.pulumi.rabbitmq.PermissionsArgs;
import com.pulumi.rabbitmq.inputs.PermissionsPermissionsArgs;
import com.pulumi.rabbitmq.Exchange;
import com.pulumi.rabbitmq.ExchangeArgs;
import com.pulumi.rabbitmq.inputs.ExchangeSettingsArgs;
import com.pulumi.rabbitmq.Queue;
import com.pulumi.rabbitmq.QueueArgs;
import com.pulumi.rabbitmq.inputs.QueueSettingsArgs;
import com.pulumi.rabbitmq.Binding;
import com.pulumi.rabbitmq.BindingArgs;
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 testVHost = new VHost("testVHost");

        var guest = new Permissions("guest", PermissionsArgs.builder()        
            .permissions(PermissionsPermissionsArgs.builder()
                .configure(".*")
                .read(".*")
                .write(".*")
                .build())
            .user("guest")
            .vhost(testVHost.name())
            .build());

        var testExchange = new Exchange("testExchange", ExchangeArgs.builder()        
            .settings(ExchangeSettingsArgs.builder()
                .autoDelete(true)
                .durable(false)
                .type("fanout")
                .build())
            .vhost(guest.vhost())
            .build());

        var testQueue = new Queue("testQueue", QueueArgs.builder()        
            .settings(QueueSettingsArgs.builder()
                .autoDelete(false)
                .durable(true)
                .build())
            .vhost(guest.vhost())
            .build());

        var testBinding = new Binding("testBinding", BindingArgs.builder()        
            .destination(testQueue.name())
            .destinationType("queue")
            .routingKey("#")
            .source(testExchange.name())
            .vhost(testVHost.name())
            .build());

    }
}

import pulumi
import pulumi_rabbitmq as rabbitmq

test_v_host = rabbitmq.VHost("testVHost")
guest = rabbitmq.Permissions("guest",
    permissions=rabbitmq.PermissionsPermissionsArgs(
        configure=".*",
        read=".*",
        write=".*",
    ),
    user="guest",
    vhost=test_v_host.name)
test_exchange = rabbitmq.Exchange("testExchange",
    settings=rabbitmq.ExchangeSettingsArgs(
        auto_delete=True,
        durable=False,
        type="fanout",
    ),
    vhost=guest.vhost)
test_queue = rabbitmq.Queue("testQueue",
    settings=rabbitmq.QueueSettingsArgs(
        auto_delete=False,
        durable=True,
    ),
    vhost=guest.vhost)
test_binding = rabbitmq.Binding("testBinding",
    destination=test_queue.name,
    destination_type="queue",
    routing_key="#",
    source=test_exchange.name,
    vhost=test_v_host.name)

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

const testVHost = new rabbitmq.VHost("testVHost", {});
const guest = new rabbitmq.Permissions("guest", {
    permissions: {
        configure: ".*",
        read: ".*",
        write: ".*",
    },
    user: "guest",
    vhost: testVHost.name,
});
const testExchange = new rabbitmq.Exchange("testExchange", {
    settings: {
        autoDelete: true,
        durable: false,
        type: "fanout",
    },
    vhost: guest.vhost,
});
const testQueue = new rabbitmq.Queue("testQueue", {
    settings: {
        autoDelete: false,
        durable: true,
    },
    vhost: guest.vhost,
});
const testBinding = new rabbitmq.Binding("testBinding", {
    destination: testQueue.name,
    destinationType: "queue",
    routingKey: "#",
    source: testExchange.name,
    vhost: testVHost.name,
});

resources:
  testVHost:
    type: rabbitmq:VHost
  guest:
    type: rabbitmq:Permissions
    properties:
      permissions:
        configure: .*
        read: .*
        write: .*
      user: guest
      vhost: ${testVHost.name}
  testExchange:
    type: rabbitmq:Exchange
    properties:
      settings:
        autoDelete: true
        durable: false
        type: fanout
      vhost: ${guest.vhost}
  testQueue:
    type: rabbitmq:Queue
    properties:
      settings:
        autoDelete: false
        durable: true
      vhost: ${guest.vhost}
  testBinding:
    type: rabbitmq:Binding
    properties:
      destination: ${testQueue.name}
      destinationType: queue
      routingKey: '#'
      source: ${testExchange.name}
      vhost: ${testVHost.name}