Tutorial: Implantar um aplicativo Web ASP.NET usando o Azure Cosmos DB para NoSQL, identidade gerenciada e AKS via Bicep

APLICA-SE A: NoSQL

Neste tutorial, você implantará uma referência ASP.NET aplicativo Web em um cluster do Serviço Kubernetes do Azure (AKS) que se conecta ao Azure Cosmos DB para NoSQL.

O Azure Cosmos DB é uma plataforma de banco de dados distribuída totalmente gerenciada para desenvolvimento de aplicativos modernos com NoSQL ou bancos de dados relacionais.

O AKS é um serviço Kubernetes gerenciado que ajuda você a implantar e gerenciar clusters rapidamente.

Pré-requisitos

As seguintes ferramentas são necessárias para compilar o aplicativo Web ASP.NET e criar sua imagem de contêiner:

• Área de trabalho do Docker
• Visual Studio Code
  • Extensão C# para o Visual Studio Code
  • Extensão do Docker para Visual Studio Code
  • Extensão da Conta do Azure para Visual Studio Code

Descrição geral

Este tutorial usa uma abordagem de infraestrutura como código (IaC) para implantar os recursos no Azure. Você usará o Bicep, que é uma nova linguagem declarativa que oferece os mesmos recursos dos modelos do Azure Resource Manager. No entanto, o Bicep inclui uma sintaxe mais concisa e fácil de usar.

Os módulos Bicep implantarão os seguintes recursos do Azure dentro do escopo da assinatura de destino:

• Um grupo de recursos para organizar os recursos
• Uma identidade gerenciada para autenticação
• Um registro de contêiner para armazenar imagens de contêiner
• Um cluster AKS
• Uma rede virtual para configurar o AKS
• Uma conta do Azure Cosmos DB para NoSQL, juntamente com um banco de dados, um contêiner e a função SQL
• Um cofre de chaves para armazenar chaves seguras
• (Opcional) Um espaço de trabalho do Log Analytics

Este tutorial usa as seguintes práticas recomendadas de segurança com o Azure Cosmos DB:

• Implemente o controle de acesso usando o controle de acesso baseado em função (RBAC) e uma identidade gerenciada. Esses recursos eliminam a necessidade de os desenvolvedores gerenciarem segredos, credenciais, certificados e chaves para uma comunicação segura entre serviços.
• Limite o acesso do Azure Cosmos DB à sub-rede AKS configurando um ponto de extremidade de serviço de rede virtual.
• Defina disableLocalAuth = true o recurso para impor o databaseAccount RBAC como o único método de autenticação.

Faça o download dos módulos do Bíceps

Baixe ou clone os módulos Bicep da pasta Bicep do repositório GitHub azure-samples/cosmos-aks-samples:

git clone https://github.com/Azure-Samples/cosmos-aks-samples.git

cd Bicep/

Ligar à sua subscrição do Azure

Use az login para se conectar à sua assinatura padrão do Azure:

az login

Opcionalmente, use az account set com o nome ou ID de uma assinatura específica para definir a assinatura ativa se você tiver várias assinaturas:

az account set \
  --subscription <subscription-id>

Inicializar os parâmetros de implantação

Crie um arquivo param.json usando o JSON no exemplo a seguir. Substitua os {resource group name}espaços reservados , {Azure Cosmos DB account name}e por {Azure Container Registry instance name} seus próprios valores.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "rgName": {
      "value": "{resource group name}"
    },    
    "cosmosName" :{
      "value": "{Azure Cosmos DB account name}"
    },
    "acrName" :{
      "value": "{Azure Container Registry instance name}"
    }
  }
}

Criar uma implantação do Bicep

Defina variáveis de shell usando os seguintes comandos. Substitua os espaços reservados e {location} pelos {deployment name} seus próprios valores.

deploymentName='{deployment name}'  # Name of the deployment
location='{location}' # Location for deploying the resources

Dentro da pasta Bicep , use az deployment sub create para implantar o modelo no escopo de assinatura atual:

az deployment sub create \
  --name $deploymentName \
  --location $location \
  --template-file main.bicep \
  --parameters @param.json

Durante a implantação, o console emitirá uma mensagem indicando que a implantação ainda está em execução:

 / Running ..

A implantação pode levar de 20 a 30 minutos. Após a conclusão do provisionamento, o console produzirá JSON com Succeeded o estado de provisionamento:

      }
    ],
    "provisioningState": "Succeeded",
    "templateHash": "0000000000000000",
    "templateLink": null,
    "timestamp": "2022-01-01T00:00:00.000000+00:00",
    "validatedResources": null
  },
  "tags": null,
  "type": "Microsoft.Resources/deployments"
}

Você também pode ver o status da implantação no grupo de recursos:

Vincular o Registro de Contêiner do Azure ao AKS

Use os comandos a seguir para vincular sua instância do Registro de Contêiner do Azure ao AKS. Substitua os espaços reservados e {resource group name} pelos {Azure Container Registry instance name} seus próprios valores.

acrName='{Azure Container Registry instance name}'
rgName='{resource group name}'
aksName=$rgName'aks'

Execute az aks update para anexar o recurso existente do Registro de Contêiner do Azure ao cluster AKS:

az aks update \
  --resource-group $rgName \
  --name $aksName \
  --attach-acr $acrName

Conectar-se ao cluster AKS

Para gerenciar um cluster Kubernetes, use kubectl, o cliente de linha de comando do Kubernetes. Se você usa o Azure Cloud Shell, kubectl já está instalado. Para instalar kubectl localmente, use az aks install-cli:

az aks install-cli

Para configurar o kubectl para ligar ao seu cluster do Kubernetes, utilize az aks get-credentials. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.

az aks get-credentials \
  --resource-group $rgName \
  --name $aksName

Conectar os pods AKS ao Azure Key Vault

As identidades gerenciadas por pod do Microsoft Entra usam primitivos AKS para associar identidades gerenciadas para recursos e identidades do Azure no Microsoft Entra ID a pods. Você usará essas identidades para conceder acesso ao Provedor do Cofre de Chaves do Azure para o Driver CSI do Repositório de Segredos.

Use o seguinte comando para localizar os valores da ID do locatário (homeTenantId):

az account show

Use o seguinte modelo YAML para criar um arquivo secretproviderclass.yml . Substitua os espaços reservados e {resource group name} pelos {Tenant Id} seus próprios valores. Certifique-se também de que o valor para {resource group name} corresponde ao valor em param.json.

# This is a SecretProviderClass example that uses aad-pod-identity to access the key vault
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: azure-kvname-podid
spec:
  provider: azure
  parameters:
    usePodIdentity: "true"               
    keyvaultName: "{resource group name}kv"       # Replace resource group name. Bicep generates the key vault name.
    tenantId: "{Tenant Id}"              # The tenant ID of your account. Use the 'homeTenantId' attribute value from  the 'az account show' command output.

Aplicar o SecretProviderClass ao cluster AKS

Use kubectl apply para instalar o driver CSI do Secrets Store usando o YAML:

kubectl apply \
  --filename secretproviderclass.yml

Crie o aplicativo Web ASP.NET

Baixe ou clone o código-fonte do aplicativo Web da pasta Application do repositório GitHub azure-samples/cosmos-aks-samples :

git clone https://github.com/Azure-Samples/cosmos-aks-samples.git

cd Application/

Abra a pasta Application no Visual Studio Code. Execute o aplicativo usando a tecla F5 ou o comando Debug: Start Debugging .

Enviar a imagem do contêiner do Docker para o Registro de Contêiner do Azure

1. Para criar uma imagem de contêiner na guia Explorer no Visual Studio Code, clique com o botão direito do mouse em Dockerfile e selecione Criar imagem.

   

2. No prompt que solicita o nome e a versão para marcar a imagem, digite o nome todo:latest.

3. Use o painel Docker para enviar a imagem criada para o Registro de Contêiner do Azure. Você encontrará a imagem construída no nó Imagens . Abra o nó todo, clique com o botão direito do mouse em Mais recente e selecione Push.

   

4. Nos prompts, selecione sua assinatura do Azure, o recurso do Registro de Contêiner do Azure e as tags de imagem. O formato da tag de imagem deve ser {acrname}.azurecr.io/todo:latest.

5. Aguarde até que o Visual Studio Code envie a imagem do contêiner para o Registro de Contêiner do Azure.

Preparar o YAML de implantação

Use o seguinte modelo YAML para criar um arquivo akstododeploy.yml . Substitua os {ACR name}espaços reservados , {Image name}, {Version}e {resource group name} por seus próprios valores.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: todo
  labels:
    aadpodidbinding: "cosmostodo-apppodidentity"
    app: todo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: todo
  template:
    metadata:
      labels:
        app: todo
        aadpodidbinding: "cosmostodo-apppodidentity"
    spec:
      containers:
      - name: mycontainer
        image: "{ACR name}/{Image name}:{Version}"   # Update per your environment; for example, myacrname.azurecr.io/todo:latest. Do not add https:// in ACR Name.
        ports:
        - containerPort: 80
        env:
        - name: KeyVaultName
          value: "{resource group name}kv"       # Replace resource group name. Key Vault name is generated by Bicep.
      nodeSelector:
        kubernetes.io/os: linux
      volumes:
        - name: secrets-store01-inline
          csi:
            driver: secrets-store.csi.k8s.io
            readOnly: true
            volumeAttributes:
              secretProviderClass: "azure-kvname-podid"       
---
    
kind: Service
apiVersion: v1
metadata:
  name: todo
spec:
  selector:
    app: todo
    aadpodidbinding: "cosmostodo-apppodidentity"    
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

Aplicar o YAML de implantação

Use kubectl apply novamente para implantar os pods de aplicativo e expor os pods por meio de um balanceador de carga:

kubectl apply \
  --filename akstododeploy.yml \
  --namespace 'my-app'

Testar a aplicação

Quando o aplicativo é executado, um serviço Kubernetes expõe o front-end do aplicativo à Internet. Este processo pode demorar alguns minutos a concluir.

Use kubectl get para visualizar o IP externo que o balanceador de carga expõe:

kubectl get services \
  --namespace "my-app"

Para acessar o aplicativo, abra o endereço IP que você recebeu como saída em um navegador.

Limpar os recursos

Para evitar cobranças do Azure, limpe os recursos desnecessários quando não precisar mais do cluster. Use az group delete e az deployment sub delete para excluir o grupo de recursos e a implantação de assinatura, respectivamente:

az group delete \
  --resource-group $rgName 
  --yes

az deployment sub delete \
  --name $deploymentName

Próximos passos

• Saiba como desenvolver um aplicativo Web com o Azure Cosmos DB.
• Saiba como consultar o Azure Cosmos DB para NoSQL.
• Saiba como atualizar seu cluster.
• Saiba como dimensionar seu cluster.
• Saiba como habilitar a implantação contínua.