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

APLICA-SE A: NoSQL

Neste tutorial, você implanta um aplicativo Web ASP .NET de referência em um cluster AKS (Azure Kubernetes Service) que conecta o Azure Cosmos DB for 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 de Kubernetes gerenciado que ajuda você a implantar e a gerenciar clusters rapidamente.

Pré-requisitos

As ferramentas a seguir serão necessárias para compilar o aplicativo Web ASP.NET e criar a imagem de contêiner:

• Docker Desktop
• Visual Studio Code
  • Extensão do C# para o Visual Studio Code
  • Extensão de Docker para Visual Studio Code
  • Extensão de conta do Azure para Visual Studio Code

Visão geral

Este tutorial usa uma abordagem de IaC (infraestrutura como código) para implantar os recursos no Azure. Você usa 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 implantam os seguintes recursos do Azure no escopo de assinatura direcionada:

• Um grupo de recursos para organizar os recursos
• Uma identidade gerenciada para autenticação
• Um registro de contêiner para armazenamento de imagens de contêiner
• Um cluster do AKS
• Uma rede virtual para configurar o AKS
• Uma conta do Azure Cosmos DB for 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 workspace do Log Analytics

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

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

Baixar os módulos do Bicep

Baixe ou clone os módulos do 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/

Conecte-se à sua assinatura do Azure

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

az login

Opcionalmente, use az account set com o nome ou a 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 seguinte exemplo. Substitua os espaços reservados {resource group name}, {Azure Cosmos DB account name} e {Azure Container Registry instance name} por 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 comandos a seguir. Substitua os espaços reservados {deployment name} e {location} pelos seus próprios valores.

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

Na 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 exibe 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 concluir o provisionamento, o console gerará JSON com Succeeded como 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 poderá ver o status de implantação no grupo de recursos:

Vincular o Registro de Contêiner do Azure com o AKS

Use os comandos a seguir para vincular sua instância de Registro de Contêiner do Azure ao AKS. Substitua os espaços reservados {Azure Container Registry instance name} e {resource group name} pelos 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 de Registro de Contêiner do Azure existente com o cluster do AKS:

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

Conecte-se ao cluster do AKS

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

az aks install-cli

Para configurar kubectl para conectar o cluster Kubernetes, use az aks get-credentials. Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.

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

Conectar os pods do AKS ao Azure Key Vault

As identidades gerenciadas por pod do Microsoft Entra usam primitivos do AKS para associar identidades gerenciadas para recursos do Azure e identidades no Microsoft Entra ID aos pods. Você usa essas identidades para conceder acesso ao Provedor do Azure Key Vault para o driver CSI (Interface de Armazenamento de Contêiner) de Repositórios de Segredos.

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

az account show

Use o modelo YAML a seguir para criar um arquivo secretproviderclass.yml. Substitua os espaços reservados {Tenant Id} e {resource group name} pelos seus próprios valores. Verifique, também, se o valor de {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 Repositório de Segredos usando o YAML:

kubectl apply \
  --filename secretproviderclass.yml

Compilar o aplicativo Web ASP.NET

Baixe ou clone o código-fonte do aplicativo Web da pasta de Aplicativo 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 Aplicativo no Visual Studio Code. Execute o aplicativo usando a chave F5 ou o comando Depurar: iniciar Depuração.

Efetuar push da imagem de 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, em seguida, selecioneCompilar Imagem.

   

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

3. Use o painel do Docker para efetuar push da imagem criada para o Registro de Contêiner do Azure. Você encontrará a imagem compilada no nó Imagens. Abra o nó todo, clique com o botão direito do mouse em mais recente e, em seguida, selecione Enviar por push.

   

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

5. Aguarde o Visual Studio Code enviar por push a imagem de contêiner ao Registro de Contêiner do Azure.

Preparar o YAML de implantação

Use este modelo YAML a seguir para criar um arquivo akstododeploy.yml. Substitua os espaços reservados {ACR name}, {Image name}, {Version} e {resource group name} pelos 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 do aplicativo e expor os pods por meio de um balanceador de carga:

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

Testar o aplicativo

Quando o aplicativo é executado, um serviço de Kubernetes expõe o front-end do aplicativo à Internet. A conclusão desse processo pode levar alguns minutos.

Use kubectl get para exibir 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 encargos do Azure, limpe os recursos desnecessários quando você 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 da assinatura, respectivamente:

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

az deployment sub delete \
  --name $deploymentName

Conteúdo relacionado

• Consulte o Azure Cosmos DB for NoSQL.
• Atualize o seu cluster.
• Dimensione o cluster.
• Habilite a implantação contínua.