Module 1 - Deploy Backend API to Azure Containers Apps (ACA)¶

In this module, we will start by creating the first microservice named ACA Web API – Backend as illustrated in the architecture diagram. Followed by that we will provision the Azure resources needed to deploy the service to Azure Container Apps using the Azure CLI.

1. Deploy Web API Backend Project to ACA¶

We will be using Azure CLI to deploy the Web API Backend to ACA as shown in the following steps:

• We will start with Installing/Upgrading the Azure Container Apps Extension.

  # Upgrade Azure CLI
  az upgrade
  # Login to Azure
  az login --use-device-code
  # Only required if you have multiple subscriptions
  az account set --subscription <name or id>
  # Install/Upgrade Azure Container Apps Extension
  az extension add --name containerapp --upgrade
  

• Define the variables below in the PowerShell console to use them across the different modules in the workshop. You should change the values of those variables to be able to create the resources successfully. Some of those variables should be unique across all Azure subscriptions such as Azure Container Registry name. Remember to replace the place holders with your own values:

  export RESOURCE_GROUP="tasks-tracker-rg"
  export LOCATION="eastus"
  export ENVIRONMENT="tasks-tracker-containerapps-env"
  export WORKSPACE_NAME="<replace this with your unique app log analytics workspace name>"
  export APPINSIGHTS_NAME="<replace this with your unique app insights name>"
  export BACKEND_API_NAME="tasksmanager-backend-api"
  export ACR_NAME="<replace this with your unique acr name>"
  export YOUR_ACA_ENV_UNIQUE_ID="<replace this with your initialls and the current day, e.g.: rbb053020>"
  

• Create a resource group to organize the services related to the application, run the below command:

  az group create \
  --name $RESOURCE_GROUP \
  --location "$LOCATION"
  

• Create an Azure Container Registry (ACR) instance in the resource group to store images of all Microservices we are going to build during this workshop. Make sure that you set the admin-enabled flag to true in order to seamlessly authenticate the Azure container app when trying to create the container app using the image stored in ACR

  az acr create \
  --resource-group $RESOURCE_GROUP \
  --name $ACR_NAME \
  --sku Basic \
  --admin-enabled true
  

• Create an Azure Log Analytics Workspace which will provide a common place to store the system and application log data from all container apps running in the environment. Each environment should have its own Log Analytics Workspace. To create it, run the command below:

  # create the log analytics workspace
  az monitor log-analytics workspace create \
  --resource-group $RESOURCE_GROUP \
  --workspace-name $WORKSPACE_NAME
  
  # retrieve workspace ID
  export WORKSPACE_ID=$(az monitor log-analytics workspace show --query customerId \
  -g $RESOURCE_GROUP \
  -n $WORKSPACE_NAME -o tsv)
  
  # retrieve workspace secret
  export WORKSPACE_SECRET=$(az monitor log-analytics workspace get-shared-keys --query primarySharedKey \
  -g $RESOURCE_GROUP \
  -n $WORKSPACE_NAME -o tsv)
  

• Create an Application Insights Instance which will be used mainly for distributed tracing between different container apps within the ACA environment to provide searching for and visualizing an end-to-end flow of a given execution or transaction. To create it, run the command below:

  # Install the application-insights extension for the CLI
  az extension add -n application-insights
  
  # Create application-insights instance
  az monitor app-insights component create \
  -g $RESOURCE_GROUP \
  -l $LOCATION \
  --app $APPINSIGHTS_NAME \
  --workspace $WORKSPACE_NAME
  
  # Get Application Insights Instrumentation Key
  export APPINSIGHTS_INSTRUMENTATIONKEY=$(az monitor app-insights component show \
  --app $APPINSIGHTS_NAME -g $RESOURCE_GROUP | jq -r '.instrumentationKey')
  

• Now we will create an Azure Container Apps Environment. As a reminder of the different ACA component check this link in the workshop introduction. The ACA environment acts as a secure boundary around a group of container apps that we are going to provision during this workshop. To create it, run the below command:

  # Create the ACA environment
  az containerapp env create \
  --name $ENVIRONMENT \
  --resource-group $RESOURCE_GROUP \
  --logs-workspace-id $WORKSPACE_ID \
  --logs-workspace-key $WORKSPACE_SECRET \
  --dapr-instrumentation-key $APPINSIGHTS_INSTRUMENTATIONKEY \
  --location $LOCATION
  

• Build the Web API project on ACR and push the docker image to ACR. Use the below command to initiate the image build and push process using ACR. The . at the end of the command represents the docker build context, in our case, we need to be on the parent directory which hosts the .csproj.

  az acr build --registry $ACR_NAME --image "tasksmanager/$BACKEND_API_NAME" --file 'TasksTracker.TasksManager.Backend.Api/Dockerfile' .
  

  Once this step is completed you can verify the results by going to the Azure portal and checking that a new repository named tasksmanager/tasksmanager-backend-api has been created and there is a new docker image with a latest tag is created.

• The last step here is to create and deploy the Web API to ACA following the below command. Remember to replace the place holders with your own values:

  az containerapp create \
  --name $BACKEND_API_NAME  \
  --resource-group $RESOURCE_GROUP \
  --environment $ENVIRONMENT \
  --image "$ACR_NAME.azurecr.io/tasksmanager/$BACKEND_API_NAME:latest" \
  --registry-server "$ACR_NAME.azurecr.io" \
  --target-port 80 \
  --ingress 'external' \
  --min-replicas 1 \
  --max-replicas 1 \
  --cpu 0.25 --memory 0.5Gi \
  --query configuration.ingress.fqdn
  

• You can now verify the deployment of the first ACA by navigating to the Azure Portal and selecting the resource group named tasks-tracker-rg that you created earlier. You should see the 5 recourses created below.

In the next module, we will see how we will add a new Frontend Web App as a microservice and how it will communicate with the backend API.