Using azure containerapp with manageddockerenvironment

Question

Pulumi · Accepted Answer

To deploy applications on Azure using Container Apps, you will need to create a few resources:

1. **Managed Environment**: This is where your containerized applications will run. You need to set up a managed environment before deploying any apps.

2. **Container App**: Your application's code runs in container apps. The image for your app is pulled from a container registry and orchestrated by the managed environment.

Below, I'll walk you through a simple program using Pulumi with the `azure-native` provider to create an Azure Container App within a Managed Docker Environment. We'll be using TypeScript to accomplish this.

First, you'll need an Azure Resource Group to contain all the resources. After that, we create the Managed Environment and finally the Container App.

Here's the program:

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

// Create an Azure Resource Group
const resourceGroup = new resources.ResourceGroup("resourceGroup");

// Create a Managed Environment for Container Apps
const managedEnvironment = new app.ManagedEnvironment("managedEnvironment", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    // Additional properties like the SKU can be set here.
});

// Create a Container App
const containerApp = new app.ContainerApp("containerApp", {
    resourceGroupName: resourceGroup.name,
    containerAppName: pulumi.interpolate`${resourceGroup.name}-app`,
    managedEnvironmentId: managedEnvironment.id,
    // Configure the container image, resources and other properties as per your requirements
    template: {
        containers: [{
            name: "my-app-container",
            image: "nginx", // Example image; replace with the path to your container image
            resources: {
                cpu: 0.5,
                memory: "1Gi",
            },
        }],
        // Define other settings such as scale, networking, environment variables, etc.
    },
    // This is an optional configuration that defines how your app will handle incoming traffic.
    configuration: {
        ingress: {
            external: true, // If set to true, your app will be available from the internet.
            targetPort: 80, // Replace with the port your application listens on.
        },
    },
});

// Export the URL of the container app
export const url = pulumi.interpolate`https://${containerApp.configuration.apply(config => config?.ingress?.fqdn)}`;
```

In this program:

- We start by importing the necessary Pulumi libraries.
- Then, we create an Azure Resource Group which is a logical container that holds related resources for an Azure solution.
- Next, we create a Managed Environment for the Container Apps. This environment is responsible for providing the infrastructure that supports the operation of your containerized applications.
- After setting up the environment, we define a Container App resource. In this resource, we specify the name of the container, the image to be run (in this case, we used `nginx` as an example), and its resources (CPU and memory).
- The `configuration` block allows us to define ingress settings, making the app accessible over the internet. This is also where you can define other settings such as environment variables, secrets, and volumes for your application.
- Lastly, we export the URL where the container app will be available.

To apply this configuration to your Azure subscription, save the code in a file with a `.ts` extension, then run `pulumi up` using the Pulumi CLI. This command will provision the resources as described in the program in your Azure subscription.