azure-native.containerservice.JWTAuthenticator

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

return await Deployment.RunAsync(() => 
{
    var jwtAuthenticator = new AzureNative.ContainerService.JWTAuthenticator("jwtAuthenticator", new()
    {
        JwtAuthenticatorName = "jwt1",
        Properties = new AzureNative.ContainerService.Inputs.JWTAuthenticatorPropertiesArgs
        {
            ClaimMappings = new AzureNative.ContainerService.Inputs.JWTAuthenticatorClaimMappingsArgs
            {
                Extra = new[]
                {
                    new AzureNative.ContainerService.Inputs.JWTAuthenticatorExtraClaimMappingExpressionArgs
                    {
                        Key = "example.com/extrakey",
                        ValueExpression = "claims.customfield",
                    },
                },
                Groups = new AzureNative.ContainerService.Inputs.JWTAuthenticatorClaimMappingExpressionArgs
                {
                    Expression = "claims.groups.split(',').map(group, 'aks:jwt:' + group)",
                },
                Username = new AzureNative.ContainerService.Inputs.JWTAuthenticatorClaimMappingExpressionArgs
                {
                    Expression = "'aks:jwt:' + claims.sub",
                },
            },
            ClaimValidationRules = new[]
            {
                new AzureNative.ContainerService.Inputs.JWTAuthenticatorValidationRuleArgs
                {
                    Expression = "has(claims.sub)",
                    Message = "Sub is required",
                },
                new AzureNative.ContainerService.Inputs.JWTAuthenticatorValidationRuleArgs
                {
                    Expression = "claims.sub != ''",
                    Message = "Sub cannot be empty",
                },
            },
            Issuer = new AzureNative.ContainerService.Inputs.JWTAuthenticatorIssuerArgs
            {
                Audiences = new[]
                {
                    "https://example.com/audience1",
                    "https://example.com/audience2",
                },
                Url = "https://example.com",
            },
            UserValidationRules = new[]
            {
                new AzureNative.ContainerService.Inputs.JWTAuthenticatorValidationRuleArgs
                {
                    Expression = "user.groups.all(group, group.startsWith('aks:jwt:admin:'))",
                    Message = "Must be in admin user group",
                },
            },
        },
        ResourceGroupName = "rg1",
        ResourceName = "clustername1",
    });

});

package main

import (
	containerservice "github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerservice.NewJWTAuthenticator(ctx, "jwtAuthenticator", &containerservice.JWTAuthenticatorArgs{
			JwtAuthenticatorName: pulumi.String("jwt1"),
			Properties: &containerservice.JWTAuthenticatorPropertiesArgs{
				ClaimMappings: &containerservice.JWTAuthenticatorClaimMappingsArgs{
					Extra: containerservice.JWTAuthenticatorExtraClaimMappingExpressionArray{
						&containerservice.JWTAuthenticatorExtraClaimMappingExpressionArgs{
							Key:             pulumi.String("example.com/extrakey"),
							ValueExpression: pulumi.String("claims.customfield"),
						},
					},
					Groups: &containerservice.JWTAuthenticatorClaimMappingExpressionArgs{
						Expression: pulumi.String("claims.groups.split(',').map(group, 'aks:jwt:' + group)"),
					},
					Username: &containerservice.JWTAuthenticatorClaimMappingExpressionArgs{
						Expression: pulumi.String("'aks:jwt:' + claims.sub"),
					},
				},
				ClaimValidationRules: containerservice.JWTAuthenticatorValidationRuleArray{
					&containerservice.JWTAuthenticatorValidationRuleArgs{
						Expression: pulumi.String("has(claims.sub)"),
						Message:    pulumi.String("Sub is required"),
					},
					&containerservice.JWTAuthenticatorValidationRuleArgs{
						Expression: pulumi.String("claims.sub != ''"),
						Message:    pulumi.String("Sub cannot be empty"),
					},
				},
				Issuer: &containerservice.JWTAuthenticatorIssuerArgs{
					Audiences: pulumi.StringArray{
						pulumi.String("https://example.com/audience1"),
						pulumi.String("https://example.com/audience2"),
					},
					Url: pulumi.String("https://example.com"),
				},
				UserValidationRules: containerservice.JWTAuthenticatorValidationRuleArray{
					&containerservice.JWTAuthenticatorValidationRuleArgs{
						Expression: pulumi.String("user.groups.all(group, group.startsWith('aks:jwt:admin:'))"),
						Message:    pulumi.String("Must be in admin user group"),
					},
				},
			},
			ResourceGroupName: pulumi.String("rg1"),
			ResourceName:      pulumi.String("clustername1"),
		})
		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.azurenative.containerservice.JWTAuthenticator;
import com.pulumi.azurenative.containerservice.JWTAuthenticatorArgs;
import com.pulumi.azurenative.containerservice.inputs.JWTAuthenticatorPropertiesArgs;
import com.pulumi.azurenative.containerservice.inputs.JWTAuthenticatorClaimMappingsArgs;
import com.pulumi.azurenative.containerservice.inputs.JWTAuthenticatorClaimMappingExpressionArgs;
import com.pulumi.azurenative.containerservice.inputs.JWTAuthenticatorIssuerArgs;
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 jwtAuthenticator = new JWTAuthenticator("jwtAuthenticator", JWTAuthenticatorArgs.builder()
            .jwtAuthenticatorName("jwt1")
            .properties(JWTAuthenticatorPropertiesArgs.builder()
                .claimMappings(JWTAuthenticatorClaimMappingsArgs.builder()
                    .extra(JWTAuthenticatorExtraClaimMappingExpressionArgs.builder()
                        .key("example.com/extrakey")
                        .valueExpression("claims.customfield")
                        .build())
                    .groups(JWTAuthenticatorClaimMappingExpressionArgs.builder()
                        .expression("claims.groups.split(',').map(group, 'aks:jwt:' + group)")
                        .build())
                    .username(JWTAuthenticatorClaimMappingExpressionArgs.builder()
                        .expression("'aks:jwt:' + claims.sub")
                        .build())
                    .build())
                .claimValidationRules(                
                    JWTAuthenticatorValidationRuleArgs.builder()
                        .expression("has(claims.sub)")
                        .message("Sub is required")
                        .build(),
                    JWTAuthenticatorValidationRuleArgs.builder()
                        .expression("claims.sub != ''")
                        .message("Sub cannot be empty")
                        .build())
                .issuer(JWTAuthenticatorIssuerArgs.builder()
                    .audiences(                    
                        "https://example.com/audience1",
                        "https://example.com/audience2")
                    .url("https://example.com")
                    .build())
                .userValidationRules(JWTAuthenticatorValidationRuleArgs.builder()
                    .expression("user.groups.all(group, group.startsWith('aks:jwt:admin:'))")
                    .message("Must be in admin user group")
                    .build())
                .build())
            .resourceGroupName("rg1")
            .resourceName("clustername1")
            .build());

    }
}

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const jwtAuthenticator = new azure_native.containerservice.JWTAuthenticator("jwtAuthenticator", {
    jwtAuthenticatorName: "jwt1",
    properties: {
        claimMappings: {
            extra: [{
                key: "example.com/extrakey",
                valueExpression: "claims.customfield",
            }],
            groups: {
                expression: "claims.groups.split(',').map(group, 'aks:jwt:' + group)",
            },
            username: {
                expression: "'aks:jwt:' + claims.sub",
            },
        },
        claimValidationRules: [
            {
                expression: "has(claims.sub)",
                message: "Sub is required",
            },
            {
                expression: "claims.sub != ''",
                message: "Sub cannot be empty",
            },
        ],
        issuer: {
            audiences: [
                "https://example.com/audience1",
                "https://example.com/audience2",
            ],
            url: "https://example.com",
        },
        userValidationRules: [{
            expression: "user.groups.all(group, group.startsWith('aks:jwt:admin:'))",
            message: "Must be in admin user group",
        }],
    },
    resourceGroupName: "rg1",
    resourceName: "clustername1",
});

import pulumi
import pulumi_azure_native as azure_native

jwt_authenticator = azure_native.containerservice.JWTAuthenticator("jwtAuthenticator",
    jwt_authenticator_name="jwt1",
    properties={
        "claim_mappings": {
            "extra": [{
                "key": "example.com/extrakey",
                "value_expression": "claims.customfield",
            }],
            "groups": {
                "expression": "claims.groups.split(',').map(group, 'aks:jwt:' + group)",
            },
            "username": {
                "expression": "'aks:jwt:' + claims.sub",
            },
        },
        "claim_validation_rules": [
            {
                "expression": "has(claims.sub)",
                "message": "Sub is required",
            },
            {
                "expression": "claims.sub != ''",
                "message": "Sub cannot be empty",
            },
        ],
        "issuer": {
            "audiences": [
                "https://example.com/audience1",
                "https://example.com/audience2",
            ],
            "url": "https://example.com",
        },
        "user_validation_rules": [{
            "expression": "user.groups.all(group, group.startsWith('aks:jwt:admin:'))",
            "message": "Must be in admin user group",
        }],
    },
    resource_group_name="rg1",
    resource_name_="clustername1")

resources:
  jwtAuthenticator:
    type: azure-native:containerservice:JWTAuthenticator
    properties:
      jwtAuthenticatorName: jwt1
      properties:
        claimMappings:
          extra:
            - key: example.com/extrakey
              valueExpression: claims.customfield
          groups:
            expression: claims.groups.split(',').map(group, 'aks:jwt:' + group)
          username:
            expression: '''aks:jwt:'' + claims.sub'
        claimValidationRules:
          - expression: has(claims.sub)
            message: Sub is required
          - expression: claims.sub != ''
            message: Sub cannot be empty
        issuer:
          audiences:
            - https://example.com/audience1
            - https://example.com/audience2
          url: https://example.com
        userValidationRules:
          - expression: user.groups.all(group, group.startsWith('aks:jwt:admin:'))
            message: Must be in admin user group
      resourceGroupName: rg1
      resourceName: clustername1