Sandboxing de pod (visualização) com o Serviço Kubernetes do Azure (AKS)

Artigo
11/01/2024

Para ajudar a proteger suas cargas de trabalho de contêiner contra códigos não confiáveis ou potencialmente mal-intencionados, o AKS agora inclui um mecanismo chamado Pod Sandboxing (visualização). O Pod Sandboxing fornece um limite de isolamento entre o aplicativo de contêiner e o kernel compartilhado e os recursos de computação do host do contêiner. Por exemplo, CPU, memória e rede. O Pod Sandboxing complementa outras medidas de segurança ou controles de proteção de dados com sua arquitetura geral para ajudá-lo a atender aos requisitos de conformidade regulamentares, do setor ou de governança para proteger informações confidenciais.

Este artigo ajuda você a entender esse novo recurso e como implementá-lo.

Pré-requisitos

A CLI do Azure versão 2.44.1 ou posterior. Execute az --version para localizar a versão e execute az upgrade para atualizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).
A aks-preview extensão da CLI do Azure versão 0.5.123 ou posterior.
Registre o KataVMIsolationPreview recurso em sua assinatura do Azure.
O AKS suporta Pod Sandboxing (pré-visualização) na versão 1.24.0 e superior com todos os plugins de rede AKS.
Para gerenciar um cluster Kubernetes, use o kubectl do cliente de linha de comando Kubernetes. O Azure Cloud Shell vem com kubectlo . Você pode instalar o kubectl localmente usando o comando az aks install-cli .

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

Importante

Os recursos de visualização do AKS estão disponíveis em uma base de autosserviço e opt-in. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As visualizações do AKS são parcialmente cobertas pelo suporte ao cliente com base no melhor esforço. Como tal, estas funcionalidades não se destinam a utilização em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

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

Registrar o sinalizador de recurso KataVMIsolationPreview

Registre o KataVMIsolationPreview sinalizador de recurso usando o comando az feature register , conforme mostrado no exemplo a seguir:

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

Leva alguns minutos para que o status mostre Registrado. Verifique o status do registro usando o comando az feature show :

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

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

az provider register --namespace "Microsoft.ContainerService"

Limitações

A seguir estão as restrições com esta visualização do Pod Sandboxing (visualização):

Os contêineres Kata podem não atingir os limites de desempenho de IOPS que os contêineres tradicionais podem alcançar nos Arquivos do Azure e no SSD local de alto desempenho.
O Microsoft Defender for Containers não oferece suporte à avaliação de pods de tempo de execução do Kata.
A rede host Kata não é suportada.

Como funciona

Para obter essa funcionalidade no AKS, o Kata Containers em execução no host de contêiner do Azure Linux para a pilha AKS oferece isolamento imposto por hardware. O Pod Sandboxing estende os benefícios do isolamento de hardware, como um kernel separado para cada pod Kata. O isolamento de hardware aloca recursos para cada pod e não os compartilha com outros contêineres Kata ou contêineres de namespace em execução no mesmo host.

A arquitetura da solução é baseada nos seguintes componentes:

O host de contêiner do Azure Linux para AKS
Hipervisor Microsoft Hyper-V
Kernel Linux Dom0 ajustado ao Azure
Monitor de máquina virtual (VMM) de hipervisor na nuvem de código aberto
Integração com o framework Kata Container

A implantação do Pod Sandboxing usando Kata Containers é semelhante ao fluxo de trabalho padrão em contêineres para implantar contêineres. A implantação inclui opções kata-runtime que você pode definir no modelo pod.

Para usar esse recurso com um pod, a única diferença é adicionar runtimeClassName kata-mshv-vm-isolation à especificação do pod.

Quando um pod usa o kata-mshv-vm-isolation runtimeClass, ele cria uma VM para servir como a sandbox do pod para hospedar os contêineres. A memória padrão da VM é de 2 GB e a CPU padrão é um núcleo se o manifesto de recurso de contêiner (containers[].resources.limits) não especificar um limite para CPU e memória. Quando você especifica um limite para CPU ou memória no manifesto do recurso de contêiner, a VM tem com o 1 argumento para usar um + xCPU, e containers[].resources.limits.memory com o 2 argumento para especificar 2 GB + yMemory.containers[].resources.limits.cpu Os contêineres só podem usar CPU e memória até os limites dos contêineres. Os containers[].resources.requests são ignorados nesta pré-visualização enquanto trabalhamos para reduzir a sobrecarga de CPU e memória.

Implantar novo cluster

Execute as etapas a seguir para implantar um cluster do Azure Linux AKS usando a CLI do Azure.

Crie um cluster AKS usando o comando az aks create e especificando os seguintes parâmetros:
- --workload-runtime: especifique KataMshvVmIsolation para habilitar o recurso Pod Sandboxing no pool de nós. Com este parâmetro, estes outros parâmetros devem satisfazer os seguintes requisitos: Caso contrário, o comando falhará e relatará um problema com o(s) parâmetro(s) correspondente(s).
- --os-sku: AzureLinux. Apenas o Azure Linux os-sku suporta esta funcionalidade nesta versão de pré-visualização.
- --node-vm-size: Qualquer tamanho de VM do Azure que seja uma VM de geração 2 e ofereça suporte a trabalhos de virtualização aninhada. Por exemplo, VMs Dsv3 .
O exemplo a seguir cria um cluster chamado myAKSCluster com um nó no myResourceGroup:
```
az aks create 
    --name myAKSCluster \
    --resource-group myResourceGroup \
    --os-sku AzureLinux \
    --workload-runtime KataMshvVmIsolation \
    --node-vm-size Standard_D4s_v3 \
    --node-count 1 \
    --generate-ssh-keys
```
Execute o seguinte comando para obter credenciais de acesso para o cluster Kubernetes. Use o comando az aks get-credentials e substitua os valores do nome do cluster e do nome do grupo de recursos.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Liste todos os Pods em todos os namespaces usando o comando kubectl get pods .
```
kubectl get pods --all-namespaces
```

Implantar em um cluster existente

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

Siga as etapas para registrar o sinalizador de recurso KataVMIsolationPreview .
Verifique se o cluster está executando o Kubernetes versão 1.24.0 e superior.

Use o comando a seguir para habilitar o Pod Sandboxing (visualização) criando um pool de nós para hospedá-lo.

Adicione um pool de nós ao seu cluster AKS usando o comando az aks nodepool add . Especifique os parâmetros seguintes:
- --resource-group: Insira o nome de um grupo de recursos existente para criar o cluster AKS.
- --cluster-name: Insira um nome exclusivo para o cluster AKS, como myAKSCluster.
- --name: insira um nome exclusivo para o pool de nós de clusters, como nodepool2.
- --workload-runtime: especifique KataMshvVmIsolation para habilitar o recurso Pod Sandboxing no pool de nós. Juntamente com o --workload-runtime parâmetro, estes outros parâmetros devem satisfazer os seguintes requisitos: Caso contrário, o comando falhará e relatará um problema com o(s) parâmetro(s) correspondente(s).
  - --os-sku: AzureLinux. Somente o Azure Linux os-sku dá suporte a esse recurso na versão de visualização.
  - --node-vm-size: Qualquer tamanho de VM do Azure que seja uma VM de geração 2 e ofereça suporte a trabalhos de virtualização aninhada. Por exemplo, VMs Dsv3 .
O exemplo a seguir adiciona um pool de nós a myAKSCluster com um nó em nodepool2 no myResourceGroup:
```
az aks nodepool add --cluster-name myAKSCluster --resource-group myResourceGroup --name nodepool2 --os-sku AzureLinux --workload-runtime KataMshvVmIsolation --node-vm-size Standard_D4s_v3
```
Execute o comando az aks update para habilitar o pod sandboxing (visualização) no cluster.
```
az aks update --name myAKSCluster --resource-group myResourceGroup
```

Implantar um aplicativo confiável

Para demonstrar a implantação de um aplicativo confiável no kernel compartilhado no cluster AKS, execute as etapas a seguir.

Crie um arquivo chamado trusted-app.yaml para descrever um pod confiável e cole o manifesto a seguir.

kind: Pod
apiVersion: v1
metadata:
  name: trusted
spec:
  containers:
  - name: trusted
    image: mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11
    command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5 ; done"]

Implante o pod do Kubernetes executando o comando kubectl apply e especifique seu arquivo trusted-app.yaml :
```
kubectl apply -f trusted-app.yaml
```
A saída do comando é semelhante ao seguinte exemplo:
```
pod/trusted created
```

Implantar um aplicativo não confiável

Para demonstrar a implantação de um aplicativo não confiável na sandbox do pod no cluster AKS, execute as etapas a seguir.

Crie um arquivo chamado untrusted-app.yaml para descrever um pod não confiável e cole o manifesto a seguir.

kind: Pod
apiVersion: v1
metadata:
  name: untrusted
spec:
  runtimeClassName: kata-mshv-vm-isolation
  containers:
  - name: untrusted
    image: mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11
    command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5 ; done"]

O valor para runtimeClassNameSpec é kata-mhsv-vm-isolation.

Implante o pod do Kubernetes executando o comando kubectl apply e especifique seu arquivo untrusted-app.yaml :
```
kubectl apply -f untrusted-app.yaml
```
A saída do comando é semelhante ao seguinte exemplo:
```
pod/untrusted created
```

Verificar a configuração do Kernel Isolation

Para acessar um contêiner dentro do cluster AKS, inicie uma sessão de shell executando o comando kubectl exec . Neste exemplo, você está acessando o contêiner dentro do pod não confiável .
```
kubectl exec -it untrusted -- /bin/bash
```
O Kubectl se conecta ao cluster, é executado /bin/sh dentro do primeiro contêiner dentro do pod não confiável e encaminha os fluxos de entrada e saída do terminal para o processo do contêiner. Você também pode iniciar uma sessão de shell no contêiner que hospeda o pod confiável .
Depois de iniciar uma sessão de shell no contêiner do pod não confiável , você pode executar comandos para verificar se o contêiner não confiável está sendo executado em uma área restrita do pod. Você notará que ele tem uma versão do kernel diferente em comparação com o contêiner confiável fora da sandbox.

Para ver a versão do kernel, execute o seguinte comando:
```
uname -r
```
O exemplo a seguir é semelhante à saída do kernel da sandbox pod:
```
root@untrusted:/# uname -r
5.15.48.1-8.cm2
```
Inicie uma sessão de shell no contêiner do pod confiável para verificar a saída do kernel:
```
kubectl exec -it trusted -- /bin/bash
```
Para ver a versão do kernel, execute o seguinte comando:
```
uname -r
```
O exemplo a seguir é semelhante à saída da VM que está executando o pod confiável , que é um kernel diferente do pod não confiável em execução na sandbox do pod:
```
5.15.80.mshv2-hvl1.m2
```

Limpeza

Quando terminar de avaliar esse recurso, para evitar cobranças do Azure, limpe seus recursos desnecessários. Se você implantou um novo cluster como parte de sua avaliação ou teste, poderá excluí-lo usando o comando az aks delete .

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

Se você ativou o Pod Sandboxing (visualização) em um cluster existente, poderá remover o(s) pod(s) usando o comando kubectl delete pod .

kubectl delete pod pod-name

Próximos passos

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

Partilhar via