pulumi-azure-native-kotlin/com.pulumi.azurenative.kubernetesconfiguration.kotlin/FluxConfiguration

FluxConfiguration

class FluxConfiguration : KotlinCustomResource

The Flux Configuration object returned in Get & Put response. Azure REST API version: 2023-05-01. Prior API version in Azure Native 1.x: 2021-11-01-preview. Other available API versions: 2021-11-01-preview, 2022-01-01-preview.

Example Usage

Create Flux Configuration

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var fluxConfiguration = new AzureNative.KubernetesConfiguration.FluxConfiguration("fluxConfiguration", new()
    {
        ClusterName = "clusterName1",
        ClusterResourceName = "connectedClusters",
        ClusterRp = "Microsoft.Kubernetes",
        FluxConfigurationName = "srs-fluxconfig",
        GitRepository = new AzureNative.KubernetesConfiguration.Inputs.GitRepositoryDefinitionArgs
        {
            HttpsCACert = "ZXhhbXBsZWNlcnRpZmljYXRl",
            RepositoryRef = new AzureNative.KubernetesConfiguration.Inputs.RepositoryRefDefinitionArgs
            {
                Branch = "master",
            },
            SyncIntervalInSeconds = 600,
            TimeoutInSeconds = 600,
            Url = "https://github.com/Azure/arc-k8s-demo",
        },
        Kustomizations =
        {
            { "srs-kustomization1", new AzureNative.KubernetesConfiguration.Inputs.KustomizationDefinitionArgs
            {
                DependsOn = new() { },
                Path = "./test/path",
                PostBuild = new AzureNative.KubernetesConfiguration.Inputs.PostBuildDefinitionArgs
                {
                    Substitute =
                    {
                        { "cluster_env", "prod" },
                        { "replica_count", "2" },
                    },
                    SubstituteFrom = new[]
                    {
                        new AzureNative.KubernetesConfiguration.Inputs.SubstituteFromDefinitionArgs
                        {
                            Kind = "ConfigMap",
                            Name = "cluster-test",
                            Optional = true,
                        },
                    },
                },
                SyncIntervalInSeconds = 600,
                TimeoutInSeconds = 600,
                Wait = true,
            } },
            { "srs-kustomization2", new AzureNative.KubernetesConfiguration.Inputs.KustomizationDefinitionArgs
            {
                DependsOn = new[]
                {
                    "srs-kustomization1",
                },
                Path = "./other/test/path",
                PostBuild = new AzureNative.KubernetesConfiguration.Inputs.PostBuildDefinitionArgs
                {
                    SubstituteFrom = new[]
                    {
                        new AzureNative.KubernetesConfiguration.Inputs.SubstituteFromDefinitionArgs
                        {
                            Kind = "ConfigMap",
                            Name = "cluster-values",
                            Optional = true,
                        },
                        new AzureNative.KubernetesConfiguration.Inputs.SubstituteFromDefinitionArgs
                        {
                            Kind = "Secret",
                            Name = "secret-name",
                            Optional = false,
                        },
                    },
                },
                Prune = false,
                RetryIntervalInSeconds = 600,
                SyncIntervalInSeconds = 600,
                TimeoutInSeconds = 600,
                Wait = false,
            } },
        },
        Namespace = "srs-namespace",
        ReconciliationWaitDuration = "PT30M",
        ResourceGroupName = "rg1",
        Scope = "cluster",
        SourceKind = "GitRepository",
        Suspend = false,
        WaitForReconciliation = true,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/kubernetesconfiguration/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kubernetesconfiguration.NewFluxConfiguration(ctx, "fluxConfiguration", &kubernetesconfiguration.FluxConfigurationArgs{
			ClusterName:           pulumi.String("clusterName1"),
			ClusterResourceName:   pulumi.String("connectedClusters"),
			ClusterRp:             pulumi.String("Microsoft.Kubernetes"),
			FluxConfigurationName: pulumi.String("srs-fluxconfig"),
			GitRepository: kubernetesconfiguration.GitRepositoryDefinitionResponse{
				HttpsCACert: pulumi.String("ZXhhbXBsZWNlcnRpZmljYXRl"),
				RepositoryRef: &kubernetesconfiguration.RepositoryRefDefinitionArgs{
					Branch: pulumi.String("master"),
				},
				SyncIntervalInSeconds: pulumi.Float64(600),
				TimeoutInSeconds:      pulumi.Float64(600),
				Url:                   pulumi.String("https://github.com/Azure/arc-k8s-demo"),
			},
			Kustomizations: kubernetesconfiguration.KustomizationDefinitionMap{
				"srs-kustomization1": &kubernetesconfiguration.KustomizationDefinitionArgs{
					DependsOn: pulumi.StringArray{},
					Path:      pulumi.String("./test/path"),
					PostBuild: &kubernetesconfiguration.PostBuildDefinitionArgs{
						Substitute: pulumi.StringMap{
							"cluster_env":   pulumi.String("prod"),
							"replica_count": pulumi.String("2"),
						},
						SubstituteFrom: kubernetesconfiguration.SubstituteFromDefinitionArray{
							&kubernetesconfiguration.SubstituteFromDefinitionArgs{
								Kind:     pulumi.String("ConfigMap"),
								Name:     pulumi.String("cluster-test"),
								Optional: pulumi.Bool(true),
							},
						},
					},
					SyncIntervalInSeconds: pulumi.Float64(600),
					TimeoutInSeconds:      pulumi.Float64(600),
					Wait:                  pulumi.Bool(true),
				},
				"srs-kustomization2": &kubernetesconfiguration.KustomizationDefinitionArgs{
					DependsOn: pulumi.StringArray{
						pulumi.String("srs-kustomization1"),
					},
					Path: pulumi.String("./other/test/path"),
					PostBuild: &kubernetesconfiguration.PostBuildDefinitionArgs{
						SubstituteFrom: kubernetesconfiguration.SubstituteFromDefinitionArray{
							&kubernetesconfiguration.SubstituteFromDefinitionArgs{
								Kind:     pulumi.String("ConfigMap"),
								Name:     pulumi.String("cluster-values"),
								Optional: pulumi.Bool(true),
							},
							&kubernetesconfiguration.SubstituteFromDefinitionArgs{
								Kind:     pulumi.String("Secret"),
								Name:     pulumi.String("secret-name"),
								Optional: pulumi.Bool(false),
							},
						},
					},
					Prune:                  pulumi.Bool(false),
					RetryIntervalInSeconds: pulumi.Float64(600),
					SyncIntervalInSeconds:  pulumi.Float64(600),
					TimeoutInSeconds:       pulumi.Float64(600),
					Wait:                   pulumi.Bool(false),
				},
			},
			Namespace:                  pulumi.String("srs-namespace"),
			ReconciliationWaitDuration: pulumi.String("PT30M"),
			ResourceGroupName:          pulumi.String("rg1"),
			Scope:                      pulumi.String("cluster"),
			SourceKind:                 pulumi.String("GitRepository"),
			Suspend:                    pulumi.Bool(false),
			WaitForReconciliation:      pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.kubernetesconfiguration.FluxConfiguration;
import com.pulumi.azurenative.kubernetesconfiguration.FluxConfigurationArgs;
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 fluxConfiguration = new FluxConfiguration("fluxConfiguration", FluxConfigurationArgs.builder()
            .clusterName("clusterName1")
            .clusterResourceName("connectedClusters")
            .clusterRp("Microsoft.Kubernetes")
            .fluxConfigurationName("srs-fluxconfig")
            .gitRepository(Map.ofEntries(
                Map.entry("httpsCACert", "ZXhhbXBsZWNlcnRpZmljYXRl"),
                Map.entry("repositoryRef", Map.of("branch", "master")),
                Map.entry("syncIntervalInSeconds", 600),
                Map.entry("timeoutInSeconds", 600),
                Map.entry("url", "https://github.com/Azure/arc-k8s-demo")
            ))
            .kustomizations(Map.ofEntries(
                Map.entry("srs-kustomization1", Map.ofEntries(
                    Map.entry("dependsOn", ),
                    Map.entry("path", "./test/path"),
                    Map.entry("postBuild", Map.ofEntries(
                        Map.entry("substitute", Map.ofEntries(
                            Map.entry("cluster_env", "prod"),
                            Map.entry("replica_count", "2")
                        )),
                        Map.entry("substituteFrom", Map.ofEntries(
                            Map.entry("kind", "ConfigMap"),
                            Map.entry("name", "cluster-test"),
                            Map.entry("optional", true)
                        ))
                    )),
                    Map.entry("syncIntervalInSeconds", 600),
                    Map.entry("timeoutInSeconds", 600),
                    Map.entry("wait", true)
                )),
                Map.entry("srs-kustomization2", Map.ofEntries(
                    Map.entry("dependsOn", "srs-kustomization1"),
                    Map.entry("path", "./other/test/path"),
                    Map.entry("postBuild", Map.of("substituteFrom",
                        Map.ofEntries(
                            Map.entry("kind", "ConfigMap"),
                            Map.entry("name", "cluster-values"),
                            Map.entry("optional", true)
                        ),
                        Map.ofEntries(
                            Map.entry("kind", "Secret"),
                            Map.entry("name", "secret-name"),
                            Map.entry("optional", false)
                        ))),
                    Map.entry("prune", false),
                    Map.entry("retryIntervalInSeconds", 600),
                    Map.entry("syncIntervalInSeconds", 600),
                    Map.entry("timeoutInSeconds", 600),
                    Map.entry("wait", false)
                ))
            ))
            .namespace("srs-namespace")
            .reconciliationWaitDuration("PT30M")
            .resourceGroupName("rg1")
            .scope("cluster")
            .sourceKind("GitRepository")
            .suspend(false)
            .waitForReconciliation(true)
            .build());
    }
}
Content copied to clipboard

Create Flux Configuration with Bucket Source Kind

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var fluxConfiguration = new AzureNative.KubernetesConfiguration.FluxConfiguration("fluxConfiguration", new()
    {
        Bucket = new AzureNative.KubernetesConfiguration.Inputs.BucketDefinitionArgs
        {
            AccessKey = "fluxminiotest",
            BucketName = "flux",
            SyncIntervalInSeconds = 1000,
            TimeoutInSeconds = 1000,
            Url = "https://fluxminiotest.az.minio.io",
        },
        ClusterName = "clusterName1",
        ClusterResourceName = "connectedClusters",
        ClusterRp = "Microsoft.Kubernetes",
        FluxConfigurationName = "srs-fluxconfig",
        Kustomizations =
        {
            { "srs-kustomization1", new AzureNative.KubernetesConfiguration.Inputs.KustomizationDefinitionArgs
            {
                DependsOn = new() { },
                Path = "./test/path",
                SyncIntervalInSeconds = 600,
                TimeoutInSeconds = 600,
            } },
            { "srs-kustomization2", new AzureNative.KubernetesConfiguration.Inputs.KustomizationDefinitionArgs
            {
                DependsOn = new[]
                {
                    "srs-kustomization1",
                },
                Path = "./other/test/path",
                Prune = false,
                RetryIntervalInSeconds = 600,
                SyncIntervalInSeconds = 600,
                TimeoutInSeconds = 600,
            } },
        },
        Namespace = "srs-namespace",
        ResourceGroupName = "rg1",
        Scope = "cluster",
        SourceKind = "Bucket",
        Suspend = false,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/kubernetesconfiguration/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kubernetesconfiguration.NewFluxConfiguration(ctx, "fluxConfiguration", &kubernetesconfiguration.FluxConfigurationArgs{
			Bucket: &kubernetesconfiguration.BucketDefinitionArgs{
				AccessKey:             pulumi.String("fluxminiotest"),
				BucketName:            pulumi.String("flux"),
				SyncIntervalInSeconds: pulumi.Float64(1000),
				TimeoutInSeconds:      pulumi.Float64(1000),
				Url:                   pulumi.String("https://fluxminiotest.az.minio.io"),
			},
			ClusterName:           pulumi.String("clusterName1"),
			ClusterResourceName:   pulumi.String("connectedClusters"),
			ClusterRp:             pulumi.String("Microsoft.Kubernetes"),
			FluxConfigurationName: pulumi.String("srs-fluxconfig"),
			Kustomizations: kubernetesconfiguration.KustomizationDefinitionMap{
				"srs-kustomization1": &kubernetesconfiguration.KustomizationDefinitionArgs{
					DependsOn:             pulumi.StringArray{},
					Path:                  pulumi.String("./test/path"),
					SyncIntervalInSeconds: pulumi.Float64(600),
					TimeoutInSeconds:      pulumi.Float64(600),
				},
				"srs-kustomization2": &kubernetesconfiguration.KustomizationDefinitionArgs{
					DependsOn: pulumi.StringArray{
						pulumi.String("srs-kustomization1"),
					},
					Path:                   pulumi.String("./other/test/path"),
					Prune:                  pulumi.Bool(false),
					RetryIntervalInSeconds: pulumi.Float64(600),
					SyncIntervalInSeconds:  pulumi.Float64(600),
					TimeoutInSeconds:       pulumi.Float64(600),
				},
			},
			Namespace:         pulumi.String("srs-namespace"),
			ResourceGroupName: pulumi.String("rg1"),
			Scope:             pulumi.String("cluster"),
			SourceKind:        pulumi.String("Bucket"),
			Suspend:           pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.kubernetesconfiguration.FluxConfiguration;
import com.pulumi.azurenative.kubernetesconfiguration.FluxConfigurationArgs;
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 fluxConfiguration = new FluxConfiguration("fluxConfiguration", FluxConfigurationArgs.builder()
            .bucket(Map.ofEntries(
                Map.entry("accessKey", "fluxminiotest"),
                Map.entry("bucketName", "flux"),
                Map.entry("syncIntervalInSeconds", 1000),
                Map.entry("timeoutInSeconds", 1000),
                Map.entry("url", "https://fluxminiotest.az.minio.io")
            ))
            .clusterName("clusterName1")
            .clusterResourceName("connectedClusters")
            .clusterRp("Microsoft.Kubernetes")
            .fluxConfigurationName("srs-fluxconfig")
            .kustomizations(Map.ofEntries(
                Map.entry("srs-kustomization1", Map.ofEntries(
                    Map.entry("dependsOn", ),
                    Map.entry("path", "./test/path"),
                    Map.entry("syncIntervalInSeconds", 600),
                    Map.entry("timeoutInSeconds", 600)
                )),
                Map.entry("srs-kustomization2", Map.ofEntries(
                    Map.entry("dependsOn", "srs-kustomization1"),
                    Map.entry("path", "./other/test/path"),
                    Map.entry("prune", false),
                    Map.entry("retryIntervalInSeconds", 600),
                    Map.entry("syncIntervalInSeconds", 600),
                    Map.entry("timeoutInSeconds", 600)
                ))
            ))
            .namespace("srs-namespace")
            .resourceGroupName("rg1")
            .scope("cluster")
            .sourceKind("Bucket")
            .suspend(false)
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:kubernetesconfiguration:FluxConfiguration srs-fluxconfig /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{clusterRp}/{clusterResourceName}/{clusterName}/providers/Microsoft.KubernetesConfiguration/fluxConfigurations/{fluxConfigurationName}
Content copied to clipboard

Properties

Link copied to clipboard
val azureBlob: Output<AzureBlobDefinitionResponse>?

Parameters to reconcile to the AzureBlob source kind type.

Link copied to clipboard
val bucket: Output<BucketDefinitionResponse>?

Parameters to reconcile to the Bucket source kind type.

Link copied to clipboard
val complianceState: Output<String>

Combined status of the Flux Kubernetes resources created by the fluxConfiguration or created by the managed objects.

Link copied to clipboard
val configurationProtectedSettings: Output<Map<String, String>>?

Key-value pairs of protected configuration settings for the configuration

Link copied to clipboard
val errorMessage: Output<String>

Error message returned to the user in the case of provisioning failure.

Link copied to clipboard
val gitRepository: Output<GitRepositoryDefinitionResponse>?

Parameters to reconcile to the GitRepository source kind type.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val kustomizations: Output<Map<String, KustomizationDefinitionResponse>>?

Array of kustomizations used to reconcile the artifact pulled by the source type on the cluster.

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val namespace: Output<String>?

The namespace to which this configuration is installed to. Maximum of 253 lower case alphanumeric characters, hyphen and period only.

Link copied to clipboard
val provisioningState: Output<String>

Status of the creation of the fluxConfiguration.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val reconciliationWaitDuration: Output<String>?

Maximum duration to wait for flux configuration reconciliation. E.g PT1H, PT5M, P1D

Link copied to clipboard
val repositoryPublicKey: Output<String>

Public Key associated with this fluxConfiguration (either generated within the cluster or provided by the user).

Link copied to clipboard
val scope: Output<String>?

Scope at which the operator will be installed.

Link copied to clipboard
val sourceKind: Output<String>?

Source Kind to pull the configuration data from.

Link copied to clipboard
val sourceSyncedCommitId: Output<String>

Branch and/or SHA of the source commit synced with the cluster.

Link copied to clipboard
val sourceUpdatedAt: Output<String>

Datetime the fluxConfiguration synced its source on the cluster.

Link copied to clipboard
val statuses: Output<List<ObjectStatusDefinitionResponse>>

Statuses of the Flux Kubernetes resources created by the fluxConfiguration or created by the managed objects provisioned by the fluxConfiguration.

Link copied to clipboard
val statusUpdatedAt: Output<String>

Datetime the fluxConfiguration synced its status on the cluster with Azure.

Link copied to clipboard
val suspend: Output<Boolean>?

Whether this configuration should suspend its reconciliation of its kustomizations and sources.

Link copied to clipboard
val systemData: Output<SystemDataResponse>

Top level metadata https://github.com/Azure/azure-resource-manager-rpc/blob/master/v1.0/common-api-contracts.md#system-metadata-for-all-azure-resources

Link copied to clipboard
val type: Output<String>

The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val waitForReconciliation: Output<Boolean>?

Whether flux configuration deployment should wait for cluster to reconcile the kustomizations.