Compartilhar via

Implantar um cluster do AKS com Contêineres Confidenciais e uma política padrão

  • Artigo

Neste artigo, você usará a CLI do Azure para implantar um cluster do Serviço de Kubernetes do Azure (AKS) e configurar Contêineres Confidenciais (versão prévia) com uma política de segurança padrão. Em seguida, o aplicativo será implantado como um Contêiner confidencial. Para saber mais, leia a Visão geral de Contêineres Confidenciais do AKS.

Em geral, começar a usar Contêineres Confidenciais do AKS envolve as etapas a seguir.

  • Implantar ou atualizar um cluster do AKS usando a CLI do Azure
  • Adicionar uma anotação ao manifesto YAML do seu pod para marcar o pod como sendo executado como um contêiner confidencial
  • Adicionar uma política de segurança ao manifesto YAML do seu pod
  • Habilitar a imposição da política de segurança
  • Implantar seu aplicativo em computação confidencial

Pré-requisitos

  • CLI do Azure versão 2.44.1 ou posterior. Execute az --version para localizar a versão e az upgrade para atualizar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.

  • A extensão aks-preview da CLI do Azure, versão 0.5.169 ou posterior.

  • A extensão confcom da CLI do Azure para Contêineres Confidenciais, versão 0.3.3 ou posterior. confcom é necessária para gerar uma política de segurança.

  • Registre o recurso Preview na sua assinatura do Azure.

  • O AKS oferece suporte a Contêineres Confidenciais (versão prévia) na versão 1.25.0 e superior.

  • Uma identidade de carga de trabalho e uma credencial de identidade federada. A credencial de identidade de carga de trabalho permite que os aplicativos Kubernetes acessem os recursos do Azure de forma segura por meio do Microsoft Entra ID com base em contas de serviço anotadas. Se você não está familiarizado com a ID de carga de trabalho do Microsoft Entra, acesse a Visão geral da ID de carga de trabalho do Microsoft Entra e confira como a Identidade de carga de trabalho funciona com o AKS.

  • A identidade que você está usando para criar o cluster tem as permissões mínimas apropriadas. Para obter mais informações sobre o acesso e identidade do AKS, confiraOpções de acesso e identidade para o Serviço de Kubernetes do Azure (AKS).

  • Para gerenciar um cluster do Kubernetes, use o cliente de linha de comando kubectl do Kubernetes. O Azure Cloud Shell vem com o kubectl. Você pode instalar o kubectl localmente usando o comando az aks install-cli.

  • Os contêineres confidenciais no AKS fornecem um contêiner sidecar de código aberto para atestação e liberação segura de chave. O sidecar integra-se a um Key Management Service (KMS), como o Azure Key Vault, para liberar uma chave para o grupo de contêineres após a conclusão da validação. Implantar um HSM Gerenciado do Azure Key Vault (Módulo de Segurança de Hardware) é opcional, mas é recomendável para dar suporte à integridade e ao atestado no nível do contêiner. Veja Provisionar e ativar um HSM Gerenciado para implantar um HSM Gerenciado.

Instalar a extensão aks-preview da CLI do Azure

Importante

As versões prévias do recurso AKS estão disponíveis em uma base de autoatendimento e aceitação. As visualizações são fornecidas "como estão" e "conforme disponíveis" e estão excluídas dos acordos de nível de serviço e da garantia limitada. As versões prévias do AKS são parcialmente cobertas pelo suporte ao cliente em uma base de melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos:

Para instalar a extensão aks-preview, execute o seguinte comando:

az extension add --name aks-preview

Execute o seguinte comando para atualizar para a versão mais recente da extensão lançada:

az extension update --name aks-preview

Instale a extensão confcom da CLI do Azure

Para instalar a extensão confcom, execute o seguinte comando:

az extension add --name confcom

Execute o seguinte comando para atualizar para a versão mais recente da extensão lançada:

az extension update --name confcom

Registre o sinalizador do recurso KataCcIsolationPreview

Registre o sinalizador de recursos KataCcIsolationPreview usando o comando az feature register, conforme mostrado no seguinte exemplo:

az feature register --namespace "Microsoft.ContainerService" --name "KataCcIsolationPreview"

Demora alguns minutos para o status exibir Registrado. Verifique o status do registro usando o comando az feature show:

az feature show --namespace "Microsoft.ContainerService" --name "KataCcIsolationPreview"

Quando o status reflete Registrado, atualize o registro do provedor de recursos Microsoft.ContainerService usando o comando az provider register:

az provider register --namespace "Microsoft.ContainerService"

Implantar um novo cluster

  1. Crie um cluster do AKS usando o comando az aks create e especificando os seguintes parâmetros:

    • --os-sku: AzureLinux. Somente a SKU do SO do Azure Linux dá suporte a esse recurso nessa versão prévia.
    • --node-vm-size: qualquer tamanho de VM do Azure que seja uma VM de geração 2 e compatível com virtualização aninhada irá funcionar. Por exemplo, VMs Standard_DC8as_cc_v5.
    • --enable-workload-identity: habilita a criação de uma ID de carga de trabalho do Microsoft Entra, permitindo que os pods usem uma identidade do Kubernetes.
    • --enable-oidc-issuer: habilita o Emissor do OpenID Connect (OIDC). Isso permite que o Microsoft Entra ID ou outra plataforma de gerenciamento de identidade e acesso de provedores de nuvem descubra as chaves de assinatura pública do servidor de API.

    O exemplo a seguir atualiza o cluster chamado myAKSCluster e cria um único pool de nós do sistema no myResourceGroup:

    az aks create --resource-group myResourceGroup --name myAKSCluster --kubernetes-version <1.25.0 and above> --os-sku AzureLinux --node-vm-size Standard_DC4as_cc_v5 --node-count 1 --enable-oidc-issuer --enable-workload-identity --generate-ssh-keys

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster. O cluster criado na etapa anterior tem um único pool de nós. Na próxima etapa, adicionamos um segundo pool de nós ao cluster.

  2. Quando o cluster estiver pronto, obtenha as credenciais do cluster usando o comando az aks get-credentials.

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

  3. Adicione um pool de nós de usuários ao myAKSCluster com dois nós no nodepool2 no myResourceGroup usando o comando az aks nodepool add. Especifique os seguintes parâmetros:

    • --workload-runtime: especifique KataCcIsolation para habilitar o recurso Contêineres Confidenciais no pool de nós. Com esse parâmetro, esses outros parâmetros devem cumprir os requisitos a seguir. Caso contrário, o comando irá falhar e notificar um problema com os parâmetros correspondentes.
    • --os-sku: AzureLinux. Somente a SKU do SO do Azure Linux dá suporte a esse recurso nessa versão prévia.
    • --node-vm-size: qualquer tamanho de VM do Azure que seja uma VM de geração 2 e compatível com virtualização aninhada irá funcionar. Por exemplo, VMs Standard_DC8as_cc_v5.
    az aks nodepool add --resource-group myResourceGroup --name nodepool2 --cluster-name myAKSCluster --node-count 2 --os-sku AzureLinux --node-vm-size Standard_DC4as_cc_v5 --workload-runtime KataCcIsolation

Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Implantar em um cluster existente

Para usar esse recurso com um cluster existente do AKS, os seguintes requisitos devem ser cumpridos:

Use o comando a seguir para habilitar os Contêineres Confidenciais (versão prévia), criando um pool de nós para hospedar o recurso.

  1. Adicione um pool de nós ao seu cluster do AKS usando o comando az aks nodepool add. Especifique os seguintes parâmetros:

    • --resource-group: insira o nome de um grupo de recursos existente para criar o cluster do AKS dentro dele.
    • --cluster-name: insira um nome exclusivo para o cluster do AKS, como myAKSCluster.
    • --name: insira um nome exclusivo para o seu pool de nós do cluster, como nodepool2.
    • --workload-runtime: especifique KataCcIsolation para habilitar o recurso no pool de nós. Paralelamente ao parâmetro --workload-runtime, esses outros parâmetros devem cumprir os requisitos a seguir. Caso contrário, o comando irá falhar e notificar um problema com os parâmetros correspondentes.
    • --os-sku: AzureLinux. Somente a SKU do SO do Azure Linux dá suporte a esse recurso nessa versão prévia.
    • --node-vm-size: qualquer tamanho de VM do Azure que seja uma VM de geração 2 e compatível com virtualização aninhada irá funcionar. Por exemplo, VMs Standard_DC8as_cc_v5.

    O exemplo a seguir adiciona um pool de nós de usuários ao myAKSCluster com dois nós no nodepool2 dentro do myResourceGroup:

    az aks nodepool add --resource-group myResourceGroup --name nodepool2 –-cluster-name myAKSCluster --node-count 2 --os-sku AzureLinux --node-vm-size Standard_DC4as_cc_v5 --workload-runtime KataCcIsolation

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

  2. Execute o comando az aks update para habilitar os Contêineres Confidenciais (versão prévia) no cluster.

    az aks update --name myAKSCluster --resource-group myResourceGroup

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

  3. Quando o cluster estiver pronto, obtenha as credenciais do cluster usando o comando az aks get-credentials.

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Configurar o contêiner

Antes de configurar o acesso ao Azure Key Vault e ao segredo, e de implantar um aplicativo como um Contêiner confidencial, você precisa concluir a configuração da identidade da carga de trabalho.

Para configurar a identidade de carga de trabalho, siga as seguintes etapas descritas no artigo Implantar e configurar a identidade de carga de trabalho:

  • Recuperar a URL do emissor de OIDC
  • Criar uma identidade gerenciada
  • Criar uma conta de serviço do Kubernetes
  • Estabelecer uma credencial de identidade federada

Importante

É necessário definir as variáveis de ambiente da seção Exportar variáveis ambientais no artigo Implantar e configurar a identidade da carga de trabalho para continuar concluindo este tutorial. Lembre-se de definir a variável SERVICE_ACCOUNT_NAMESPACE como kafka e executar o comando kubectl create namespace kafka antes de configurar a identidade da carga de trabalho.

Implantar um aplicativo confiável com kata-cc e contêiner de atestado

As etapas a seguir configuram a criptografia de ponta a ponta para mensagens Kafka usando chaves de criptografia gerenciadas por Módulos de Segurança de Hardware Gerenciados do Azure (mHSM). A chave só é liberada quando o consumidor do Kafka é executado dentro de um Contêiner Confidencial com um contêiner de provisionamento de segredo de atestado do Azure injetado no pod.

Essa configuração é baseada nos quatro componentes a seguir:

  • Cluster Kafka: um cluster Kafka simples implantado no namespace Kafka no cluster.
  • Produtor Kafka: um produtor Kafka em execução como um pod vanilla Kubernetes que envia mensagens criptografadas configuradas pelos usuários usando uma chave pública para um tópico do Kafka.
  • Consumidor Kafka: um pod consumidor kafka em execução com o runtime kata-cc, equipado com um contêiner seguro de liberação de chave para recuperar a chave privada para descriptografar mensagens do Kafka e renderizar as mensagens para a interface do usuário da Web.

Para esta versão prévia, recomendamos, para fins de teste e avaliação, criar ou usar um recurso da camada Premium do Azure Key Vault para dar suporte ao armazenamento de chaves em um módulo de segurança de hardware (HSM). Não recomendamos o uso do seu cofre de chaves de produção. Se você não tiver um Azure Key Vault, confira como Criar um cofre de chaves usando a CLI do Azure.

  1. Conceda à identidade gerenciada que você criou anteriormente, e à sua conta, acesso ao cofre de chaves. Atribua a ambas as identidades as função RBACResponsáveis pela Criptografia do Cofre de Chaves e Usuários de Criptografia do Cofre de Chaves.

    Observação

    Execute o seguinte comando para definir o escopo:

    AKV_SCOPE=$(az keyvault show --name <AZURE_AKV_RESOURCE_NAME> --query id --output tsv)

    Execute o comando a seguir para atribuir a função Responsáveis pela Criptografia do Cofre de Chaves.

    az role assignment create --role "Key Vault Crypto Officer" --assignee "${USER_ASSIGNED_IDENTITY_NAME}" --scope $AKV_SCOPE

    Execute o comando a seguir para atribuir a função Usuários de Criptografia do Cofre de Chaves.

    az role assignment create --role "Key Vault Crypto User" --assignee "${USER_ASSIGNED_IDENTITY_NAME}" --scope $AKV_SCOPE

  2. Instale o cluster kafka no namespace Kafka executando o seguinte comando:

    kubectl create -f 'https://strimzi.io/install/latest?namespace=kafka' -n kafka

  3. Execute o seguinte comando para aplicar o arquivo CR do cluster kafka.

    kubectl apply -f https://strimzi.io/examples/latest/kafka/kafka-persistent-single.yaml -n kafka

  4. Prepare a chave de criptografia/descriptografia RSA usando o bash script para a carga de trabalho no GitHub. Salve o arquivo como setup-key.sh.

  5. Defina a variável de ambiente MAA_ENDPOINT com o FQDN do URI de atestar executando o comando a seguir.

    export MAA_ENDPOINT="$(az attestation show --name "myattestationprovider" --resource-group "MyResourceGroup" --query 'attestUri' -o tsv | cut -c 9-)"

    Verifique se o FQDN do URI de atestar está no formato correto (o MAA_ENDPOINT não deve incluir o prefixo "https://"):

    echo $MAA_ENDPOINT

    Observação

    Para configurar o Atestado do Microsoft Azure, consulte Início Rápido: configurar o Atestado do Azure com a CLI do Azure.

  6. Copie o manifesto YAML a seguir e salve-o como consumer.yaml.

    apiVersion: v1
kind: Pod
metadata:
  name: kafka-golang-consumer
  namespace: kafka
  labels:
    azure.workload.identity/use: "true"
    app.kubernetes.io/name: kafka-golang-consumer
spec:
  serviceAccountName: workload-identity-sa
  runtimeClassName: kata-cc-isolation
  containers:
    - image: "mcr.microsoft.com/aci/skr:2.7"
      imagePullPolicy: Always
      name: skr
      env:
        - name: SkrSideCarArgs
          value: ewogICAgImNlcnRjYWNoZSI6IHsKCQkiZW5kcG9pbnRfdHlwZSI6ICJMb2NhbFRISU0iLAoJCSJlbmRwb2ludCI6ICIxNjkuMjU0LjE2OS4yNTQvbWV0YWRhdGEvVEhJTS9hbWQvY2VydGlmaWNhdGlvbiIKCX0gIAp9
      command:
        - /bin/skr
      volumeMounts:
        - mountPath: /opt/confidential-containers/share/kata-containers/reference-info-base64
          name: endor-loc
    - image: "mcr.microsoft.com/acc/samples/kafka/consumer:1.0"
      imagePullPolicy: Always
      name: kafka-golang-consumer
      env:
        - name: SkrClientKID
          value: kafka-encryption-demo
        - name: SkrClientMAAEndpoint
          value: sharedeus2.eus2.test.attest.azure.net
        - name: SkrClientAKVEndpoint
          value: "myKeyVault.vault.azure.net"
        - name: TOPIC
          value: kafka-demo-topic
      command:
        - /consume
      ports:
        - containerPort: 3333
          name: kafka-consumer
      resources:
        limits:
          memory: 1Gi
          cpu: 200m
  volumes:
    - name: endor-loc
      hostPath:
        path: /opt/confidential-containers/share/kata-containers/reference-info-base64
---
apiVersion: v1
kind: Service
metadata:
  name: consumer
  namespace: kafka
spec:
  type: LoadBalancer
  selector:
    app.kubernetes.io/name: kafka-golang-consumer
  ports:
    - protocol: TCP
      port: 80
      targetPort: kafka-consumer

    Observação

    Atualize o valor da variável de ambiente do pod SkrClientAKVEndpoint para corresponder ao URL do Azure Key Vault, excluindo o valor do protocolo https://. O valor do espaço reservado do valor atual é myKeyVault.vault.azure.net. Atualize o valor da variável de ambiente de pod SkrClientMAAEndpoint com o valor de MAA_ENDPOINT. Encontre o valor de MAA_ENDPOINT executando o comando echo $MAA_ENDPOINT ou o comando az attestation show --name "myattestationprovider" --resource-group "MyResourceGroup" --query 'attestUri' -o tsv | cut -c 9-.

  7. Gere a política de segurança para o manifesto YAML do consumidor Kafka e obtenha o hash da política de segurança armazenada na variável WORKLOAD_MEASUREMENT executando o seguinte comando:

    export WORKLOAD_MEASUREMENT=$(az confcom katapolicygen -y consumer.yaml --print-policy | base64 -d | sha256sum | cut -d' ' -f1)

  8. Para gerar um par de chaves assimétricas RSA (chaves públicas e privadas), execute o script setup-key.sh usando o comando a seguir. O valor <Azure Key Vault URL> deve ser <your-unique-keyvault-name>.vault.azure.net

    export MANAGED_IDENTITY=${USER_ASSIGNED_CLIENT_ID}
bash setup-key.sh "kafka-encryption-demo" <Azure Key Vault URL>

    Observação

    • A variável de ambiente MANAGED_IDENTITY é exigida pelo script do Bash setup-key.sh.

    • A chave pública será salva como kafka-encryption-demo-pub.pem depois de executar o script do Bash.

    Importante

    Caso recebe o erro ForbiddenByRbac, talvez seja necessário aguardar até 24 horas, pois os serviços de back-end para identidades gerenciadas mantêm um cache por URI de recurso por até 24 horas. Veja também: Solucionar problemas do RBAC do Azure.

  9. Para verificar se as chaves foram carregadas com sucesso no cofre de chaves, execute os seguintes comandos:

    az account set --subscription <Subscription ID>
az keyvault key list --vault-name <KeyVault Name> -o table

  10. Copie o manifesto YAML a seguir e salve-o como producer.yaml.

    apiVersion: v1
kind: Pod
metadata:
  name: kafka-producer
  namespace: kafka
spec:
  containers:
    - image: "mcr.microsoft.com/acc/samples/kafka/producer:1.0"
      name: kafka-producer
      command:
        - /produce
      env:
        - name: TOPIC
          value: kafka-demo-topic
        - name: MSG
          value: "Azure Confidential Computing"
        - name: PUBKEY
          value: |-
            -----BEGIN PUBLIC KEY-----
            MIIBojAN***AE=
            -----END PUBLIC KEY-----
      resources:
        limits:
          memory: 1Gi
          cpu: 200m

    Observação

    Atualize o valor que começa com -----BEGIN PUBLIC KEY----- e termina com cadeias de caracteres -----END PUBLIC KEY----- com o conteúdo do kafka-encryption-demo-pub.pem qual foi criado na etapa anterior.

  11. Implante os manifestos YAML consumer e producer usando os arquivos que você salvou anteriormente.

    kubectl apply -f consumer.yaml

    kubectl apply -f producer.yaml

  12. Obtenha o endereço IP do serviço Web usando o seguinte comando:

    kubectl get svc consumer -n kafka

  13. Copie e cole o endereço IP externo do serviço do consumidor no navegador e observe a mensagem descriptografada.

    O exemplo a seguir se assemelha à saída do comando:

    Welcome to Confidential Containers on AKS!
Encrypted Kafka Message:
Msg 1: Azure Confidential Computing

  14. Você também deve tentar executar o consumidor como um pod regular do Kubernetes removendo a especificação skr container e kata-cc runtime class. Como você não está executando o consumidor com a classe de runtime kata-cc, a política não é mais necessária.

  15. Remova toda a política e observe as mensagens novamente no navegador após reimplantar a carga de trabalho. As mensagens aparecem como texto cifrado em base64 porque a chave de criptografia privada não pode ser recuperada. A chave não pode ser recuperada porque o consumidor não está mais em execução em um ambiente confidencial, e o skr container está ausente, impedindo a descriptografia de mensagens.

Limpeza

Quando terminar de avaliar esse recurso, limpe seus recursos desnecessários para evitar uma cobrança do Azure. Se tiver implantado um novo cluster como parte de sua avaliação ou teste, você poderá excluir o cluster usando o comando az aks delete.

az aks delete --resource-group myResourceGroup --name myAKSCluster

Se habilitou os Contêineres Confidenciais (versão prévia) em um cluster existente, você poderá remover o(s) pod(s) usando o comando kubectl delete pod.

kubectl delete pod pod-name

Próximas etapas

  • Saiba mais sobre Hosts Dedicados do Azure para nós com seu cluster do AKS para usar o isolamento de hardware e o controle sobre eventos de manutenção da plataforma do Azure.