Partilhar via

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

  • Artigo

APLICA-SE A: NoSQL

Neste tutorial, você implanta 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.

Importante

  • Este artigo requer a versão mais recente da CLI do Azure. Para obter mais informações, consulte Instalar a CLI do Azure. Se você estiver usando o Azure Cloud Shell, a versão mais recente já está instalada.
  • Este artigo também requer a versão mais recente da CLI do Bicep na CLI do Azure. Para obter mais informações, consulte Instalar ferramentas do Bicep.
  • Se você estiver executando os comandos neste tutorial localmente em vez de no Azure Cloud Shell, certifique-se de usar uma conta de administrador.

Pré-requisitos

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

Descrição geral

Este tutorial usa uma abordagem de infraestrutura como código (IaC) para implantar os recursos no Azure. Você usa o Bicep, que é uma nova linguagem declarativa que oferece os mesmos recursos que os 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 da assinatura de destino:

Este tutorial usa as seguintes práticas recomendadas para a segurança do Azure Cosmos DB:

Gorjeta

As etapas neste tutorial usam o Azure Cosmos DB para NoSQL. No entanto, você pode aplicar os mesmos conceitos ao Azure Cosmos DB para MongoDB.

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 sign in 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.

Importante

Todos os nomes de recursos que você usa no código a seguir devem estar em conformidade com as regras de nomenclatura e restrições para recursos do Azure. Certifique-se também de que os valores de espaço reservado sejam substituídos de forma consistente e correspondam aos valores em param.json.

{
  "$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 emite 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:

Captura de ecrã do estado de implementação do grupo de recursos no portal do Azure.

Nota

Quando você cria um cluster AKS, um segundo grupo de recursos é criado automaticamente para armazenar os recursos do AKS. Para obter mais informações, consulte Por que dois grupos de recursos são criados com o 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 kubectl para se conectar ao cluster do Kubernetes, use 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ê usa essas identidades para conceder acesso ao Provedor do Cofre de Chaves do Azure para o Driver CSI (Interface de Armazenamento de Contêiner) 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.

    Captura de tela do menu de contexto no Visual Studio Code com a opção Criar imagem selecionada.

  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ê pode 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.

    Captura de tela do menu de contexto no Visual Studio Code com a opção Push selecionada.

  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

Conteúdos relacionados