authentik.OutpostProviderAttachment

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

// Create an outpost with a proxy provider
const proxy = new authentik.ProviderProxy("proxy", {
    name: "proxy",
    authorizationFlow: default_authorization_flow.id,
    externalHost: "http://foo.bar.baz",
    internalHost: "http://internal.local",
});
const outpost = new authentik.Outpost("outpost", {name: "test-outpost"});
const attachment = new authentik.OutpostProviderAttachment("attachment", {
    outpost: outpost.outpostId,
    protocolProvider: proxy.providerProxyId,
});
// Use an existing outpost (e.g. embedded outpost)
const embedded = authentik.getOutpost({
    name: "authentik Embedded Outpost",
});
const attachmentEmbedded = new authentik.OutpostProviderAttachment("attachment_embedded", {
    outpost: embedded.then(embedded => embedded.id),
    protocolProvider: proxy.providerProxyId,
});

import pulumi
import pulumi_authentik as authentik

# Create an outpost with a proxy provider
proxy = authentik.ProviderProxy("proxy",
    name="proxy",
    authorization_flow=default_authorization_flow["id"],
    external_host="http://foo.bar.baz",
    internal_host="http://internal.local")
outpost = authentik.Outpost("outpost", name="test-outpost")
attachment = authentik.OutpostProviderAttachment("attachment",
    outpost=outpost.outpost_id,
    protocol_provider=proxy.provider_proxy_id)
# Use an existing outpost (e.g. embedded outpost)
embedded = authentik.get_outpost(name="authentik Embedded Outpost")
attachment_embedded = authentik.OutpostProviderAttachment("attachment_embedded",
    outpost=embedded.id,
    protocol_provider=proxy.provider_proxy_id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create an outpost with a proxy provider
		proxy, err := authentik.NewProviderProxy(ctx, "proxy", &authentik.ProviderProxyArgs{
			Name:              pulumi.String("proxy"),
			AuthorizationFlow: pulumi.Any(default_authorization_flow.Id),
			ExternalHost:      pulumi.String("http://foo.bar.baz"),
			InternalHost:      pulumi.String("http://internal.local"),
		})
		if err != nil {
			return err
		}
		outpost, err := authentik.NewOutpost(ctx, "outpost", &authentik.OutpostArgs{
			Name: pulumi.String("test-outpost"),
		})
		if err != nil {
			return err
		}
		_, err = authentik.NewOutpostProviderAttachment(ctx, "attachment", &authentik.OutpostProviderAttachmentArgs{
			Outpost:          outpost.OutpostId,
			ProtocolProvider: proxy.ProviderProxyId,
		})
		if err != nil {
			return err
		}
		// Use an existing outpost (e.g. embedded outpost)
		embedded, err := authentik.LookupOutpost(ctx, &authentik.LookupOutpostArgs{
			Name: pulumi.StringRef("authentik Embedded Outpost"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = authentik.NewOutpostProviderAttachment(ctx, "attachment_embedded", &authentik.OutpostProviderAttachmentArgs{
			Outpost:          pulumi.String(embedded.Id),
			ProtocolProvider: proxy.ProviderProxyId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Create an outpost with a proxy provider
    var proxy = new Authentik.ProviderProxy("proxy", new()
    {
        Name = "proxy",
        AuthorizationFlow = default_authorization_flow.Id,
        ExternalHost = "http://foo.bar.baz",
        InternalHost = "http://internal.local",
    });

    var outpost = new Authentik.Outpost("outpost", new()
    {
        Name = "test-outpost",
    });

    var attachment = new Authentik.OutpostProviderAttachment("attachment", new()
    {
        Outpost = outpost.OutpostId,
        ProtocolProvider = proxy.ProviderProxyId,
    });

    // Use an existing outpost (e.g. embedded outpost)
    var embedded = Authentik.GetOutpost.Invoke(new()
    {
        Name = "authentik Embedded Outpost",
    });

    var attachmentEmbedded = new Authentik.OutpostProviderAttachment("attachment_embedded", new()
    {
        Outpost = embedded.Apply(getOutpostResult => getOutpostResult.Id),
        ProtocolProvider = proxy.ProviderProxyId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.authentik.ProviderProxy;
import com.pulumi.authentik.ProviderProxyArgs;
import com.pulumi.authentik.Outpost;
import com.pulumi.authentik.OutpostArgs;
import com.pulumi.authentik.OutpostProviderAttachment;
import com.pulumi.authentik.OutpostProviderAttachmentArgs;
import com.pulumi.authentik.AuthentikFunctions;
import com.pulumi.authentik.inputs.GetOutpostArgs;
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) {
        // Create an outpost with a proxy provider
        var proxy = new ProviderProxy("proxy", ProviderProxyArgs.builder()
            .name("proxy")
            .authorizationFlow(default_authorization_flow.id())
            .externalHost("http://foo.bar.baz")
            .internalHost("http://internal.local")
            .build());

        var outpost = new Outpost("outpost", OutpostArgs.builder()
            .name("test-outpost")
            .build());

        var attachment = new OutpostProviderAttachment("attachment", OutpostProviderAttachmentArgs.builder()
            .outpost(outpost.outpostId())
            .protocolProvider(proxy.providerProxyId())
            .build());

        // Use an existing outpost (e.g. embedded outpost)
        final var embedded = AuthentikFunctions.getOutpost(GetOutpostArgs.builder()
            .name("authentik Embedded Outpost")
            .build());

        var attachmentEmbedded = new OutpostProviderAttachment("attachmentEmbedded", OutpostProviderAttachmentArgs.builder()
            .outpost(embedded.id())
            .protocolProvider(proxy.providerProxyId())
            .build());

    }
}

resources:
  # Create an outpost with a proxy provider
  proxy:
    type: authentik:ProviderProxy
    properties:
      name: proxy
      authorizationFlow: ${["default-authorization-flow"].id}
      externalHost: http://foo.bar.baz
      internalHost: http://internal.local
  outpost:
    type: authentik:Outpost
    properties:
      name: test-outpost
  attachment:
    type: authentik:OutpostProviderAttachment
    properties:
      outpost: ${outpost.outpostId}
      protocolProvider: ${proxy.providerProxyId}
  attachmentEmbedded:
    type: authentik:OutpostProviderAttachment
    name: attachment_embedded
    properties:
      outpost: ${embedded.id}
      protocolProvider: ${proxy.providerProxyId}
variables:
  # Use an existing outpost (e.g. embedded outpost)
  embedded:
    fn::invoke:
      function: authentik:getOutpost
      arguments:
        name: authentik Embedded Outpost

var outpostProviderAttachmentResource = new Authentik.OutpostProviderAttachment("outpostProviderAttachmentResource", new()
{
    Outpost = "string",
    ProtocolProvider = 0,
    OutpostProviderAttachmentId = "string",
});

example, err := authentik.NewOutpostProviderAttachment(ctx, "outpostProviderAttachmentResource", &authentik.OutpostProviderAttachmentArgs{
	Outpost:                     pulumi.String("string"),
	ProtocolProvider:            pulumi.Float64(0),
	OutpostProviderAttachmentId: pulumi.String("string"),
})

var outpostProviderAttachmentResource = new OutpostProviderAttachment("outpostProviderAttachmentResource", OutpostProviderAttachmentArgs.builder()
    .outpost("string")
    .protocolProvider(0.0)
    .outpostProviderAttachmentId("string")
    .build());

outpost_provider_attachment_resource = authentik.OutpostProviderAttachment("outpostProviderAttachmentResource",
    outpost="string",
    protocol_provider=0,
    outpost_provider_attachment_id="string")

const outpostProviderAttachmentResource = new authentik.OutpostProviderAttachment("outpostProviderAttachmentResource", {
    outpost: "string",
    protocolProvider: 0,
    outpostProviderAttachmentId: "string",
});

type: authentik:OutpostProviderAttachment
properties:
    outpost: string
    outpostProviderAttachmentId: string
    protocolProvider: 0