Using azure-native containerregistry with kubernetesconfiguration

Question

Pulumi · Accepted Answer

If you're planning to use Azure Container Registry (ACR) along with Azure Kubernetes Configuration to manage Kubernetes resources in Azure, then you'll be interested in setting up the ACR to store your container images and then configuring Kubernetes to pull those images and deploy applications.

Let's break this process down into steps with Pulumi and TypeScript:

1. **Setting up the Azure Container Registry (ACR):** You will need an Azure Container Registry to store and manage your container images. The `azure-native.containerregistry.Registry` resource is used for this purpose.

2. **Configuring Kubernetes:** To ensure Kubernetes can pull images from ACR, we'll use `azure-native.kubernetesconfiguration.FluxConfiguration`. This will enable GitOps on the AKS cluster. Flux is a tool that can be used to automatically ensure that the state of a cluster matches the config in git. It can use the ACR as a source of container images.

Below is a TypeScript program that sets up an ACR and a Kubernetes configuration that uses that ACR. This program will work out of the box, assuming that you have already configured your Pulumi CLI and Azure provider.

Before proceeding, please ensure that all prerequisites such as setting up Azure credentials for Pulumi, having an existing AKS cluster, and the correct versions of Node.js and Pulumi installed on your machine are met.

Here is the TypeScript code:

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

// Create an Azure Container Registry
const registry = new azure_native.containerregistry.Registry("myRegistry", {
    resourceGroupName: pulumi.interpolate`rg-${pulumi.getStack()}`,
    sku: {
        name: "Basic",
    },
    location: "EastUS", // Replace with your desired region
    adminUserEnabled: true, // Enable the admin user for simplicity in this example
});

// Create a Kubernetes Flux Configuration that uses the ACR
const fluxConfig = new azure_native.kubernetesconfiguration.FluxConfiguration("myFluxConfig", {
    clusterName: "myAKSCluster", // Replace with your AKS Cluster name
    clusterResourceName: "managedClusters", // Do not change, this tells Flux it's a managed AKS cluster
    clusterRp: "Microsoft.ContainerService", // Do not change, this is the resource provider
    namespace: "flux-system", // This is the namespace Flux will operate in
    sourceKind: "GitRepository", // Assuming you're using a Git repo for Flux config source
    gitRepository: {
        url: "https://github.com/your-repo/your-flux-configs.git", // Replace with your repo URL
        repositoryRef: {
            branch: "main",
        },
    },
    resourceGroupName: pulumi.interpolate`rg-${pulumi.getStack()}`,
});

// Export the ACR login server (useful for docker login commands)
export const acrLoginServer = registry.loginServer;

// Export the FluxConfiguration
export const fluxName = fluxConfig.name;
```

With this Pulumi program, you have:

1. **Defined an Azure Container Registry**: The container registry will store your docker images that can be deployed to Kubernetes. We enabled the admin user on the ACR for simplicity, but for production scenarios, you might want to consider using service principals or managed identities for authentication.

2. **Created a FluxConfiguration resource**: This configuration enables GitOps for our AKS Cluster by pulling config changes from the specified Git repo automatically. We set the namespace for Flux and provided the URL of the Git repo that will contain our Kubernetes manifests.

3. **Exported Outputs**: Lastly, we exported the ACR login server URL to use it in your CI/CD pipeline or Docker commands and the name of the Flux configuration as useful outputs.

Please note that you need to replace placeholder strings with the actual names of your resource group, AKS cluster name, and the URL of the Git repository where you keep your Kubernetes configuration.

Run this code with Pulumi CLI, by running `pulumi up` in your terminal. This will apply the configuration and create the resources in your Azure subscription. Once the process is completed successfully, you can use the exported information for the next steps, such as setting up your CI/CD pipeline to build images and push them to the newly created ACR. Ensure your cluster is configured to pull images from the appropriate image registry in your deployment manifests.