Início Rápido: Implantar um cluster do AKS (Serviço de Kubernetes do Azure) usando um modelo do ARM
O AKS (Serviço de Kubernetes do Azure) é um serviço de Kubernetes gerenciado que permite implantar e gerenciar clusters rapidamente. Neste início rápido, você:
- Implantar um cluster do AKS usando um modelo do Azure Resource Manager.
- Executar um aplicativo de vários contêineres de exemplo com um grupo de microsserviços e front-ends da Web simulando um cenário de varejo.
Um Modelo do Azure Resource Manager é um arquivo JSON (JavaScript Object Notation) que define a infraestrutura e a configuração do seu projeto. O modelo usa a sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.
Observação
Para começar a provisionar rapidamente um cluster do AKS, este artigo inclui etapas para implantar um cluster com configurações padrão somente para fins de avaliação. Antes de implantar um cluster pronto para produção, recomendamos que você se familiarize com nossa arquitetura de referência de linha de base para considerar como ele se alinha aos seus requisitos de negócios.
Antes de começar
Este artigo pressupõe uma compreensão básica dos conceitos do Kubernetes. Para obter mais informações, confira Principais conceitos do Kubernetes para o AKS (Serviço de Kubernetes do Azure).
-
Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.
Verifique se a identidade usada para criar seu cluster tem as permissões mínimas apropriadas. Para obter mais detalhes sobre acesso e identidade do AKS, consulte Opções de acesso e identidade para o AKS (Serviço de Kubernetes do Azure).
Para implantar um modelo do ARM, é necessário ter acesso de gravação aos recursos que você implanta e acesso a todas as operações no tipo de recurso
Microsoft.Resources/deployments. Por exemplo, para implantar uma máquina virtual, você precisaMicrosoft.Compute/virtualMachines/writee permissõesMicrosoft.Resources/deployments/*. Para ver uma lista de funções e permissões, consulte Funções interna do Azure.
Depois de implantar o cluster a partir do modelo, você pode usar a CLI do Azure ou o Azure PowerShell para se conectar ao cluster e implantar o aplicativo de exemplo.
Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Início Rápido para Bash no Azure Cloud Shell.
Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Para execuções no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para ver outras opções de entrada, confira Conectar-se com a CLI do Azure.
Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.
Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.
Este artigo requer a CLI do Azure versão 2.0.64 ou posterior. Se você estiver usando o Azure Cloud Shell, a versão mais recente já está instalada lá.
Criar um par de chaves SSH
Para criar um cluster do AKS usando um arquivo modelo do ARM, forneça uma chave pública SSH. Se você precisar desse recurso, siga as etapas nesta seção. Caso contrário, pule para a seção Examinar o modelo.
Para acessar nós do AKS, conecte-se usando um par de chaves SSH (público e privado). Para criar um par de chaves SSH:
Acesse https://shell.azure.com para abrir o Cloud Shell no navegador.
Crie um par de chaves SSH usando o comando az sshkey create ou o comando
ssh-keygen.# Create an SSH key pair using Azure CLI az sshkey create --name "mySSHKey" --resource-group "myResourceGroup" # or # Create an SSH key pair using ssh-keygen ssh-keygen -t rsa -b 4096Para implantar o modelo, você deve fornecer a chave pública do par SSH. Para recuperar a chave pública, chame az sshkey show:
az sshkey show --name "mySSHKey" --resource-group "myResourceGroup" --query "publicKey"
Por padrão, os arquivos de chave SSH são criados no diretório ~/.ssh. A execução do comando az sshkey create ou ssh-keygen substituirá qualquer par de chaves SSH existente com o mesmo nome.
Para obter mais informações sobre como criar chaves SSH, confira Criar e gerenciar chaves SSH para autenticação no Azure.
Examinar o modelo
O modelo usado neste início rápido é proveniente dos Modelos de Início Rápido do Azure.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"metadata": {
"_generator": {
"name": "bicep",
"version": "0.26.170.59819",
"templateHash": "14823542069333410776"
}
},
"parameters": {
"clusterName": {
"type": "string",
"defaultValue": "aks101cluster",
"metadata": {
"description": "The name of the Managed Cluster resource."
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"metadata": {
"description": "The location of the Managed Cluster resource."
}
},
"dnsPrefix": {
"type": "string",
"metadata": {
"description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
}
},
"osDiskSizeGB": {
"type": "int",
"defaultValue": 0,
"minValue": 0,
"maxValue": 1023,
"metadata": {
"description": "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize."
}
},
"agentCount": {
"type": "int",
"defaultValue": 3,
"minValue": 1,
"maxValue": 50,
"metadata": {
"description": "The number of nodes for the cluster."
}
},
"agentVMSize": {
"type": "string",
"defaultValue": "standard_d2s_v3",
"metadata": {
"description": "The size of the Virtual Machine."
}
},
"linuxAdminUsername": {
"type": "string",
"metadata": {
"description": "User name for the Linux Virtual Machines."
}
},
"sshRSAPublicKey": {
"type": "string",
"metadata": {
"description": "Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
}
}
},
"resources": [
{
"type": "Microsoft.ContainerService/managedClusters",
"apiVersion": "2024-02-01",
"name": "[parameters('clusterName')]",
"location": "[parameters('location')]",
"identity": {
"type": "SystemAssigned"
},
"properties": {
"dnsPrefix": "[parameters('dnsPrefix')]",
"agentPoolProfiles": [
{
"name": "agentpool",
"osDiskSizeGB": "[parameters('osDiskSizeGB')]",
"count": "[parameters('agentCount')]",
"vmSize": "[parameters('agentVMSize')]",
"osType": "Linux",
"mode": "System"
}
],
"linuxProfile": {
"adminUsername": "[parameters('linuxAdminUsername')]",
"ssh": {
"publicKeys": [
{
"keyData": "[parameters('sshRSAPublicKey')]"
}
]
}
}
}
}
],
"outputs": {
"controlPlaneFQDN": {
"type": "string",
"value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-01').fqdn]"
}
}
}
O tipo de recurso definido no modelo ARM é Microsoft.ContainerService/managedClusters.
Para obter mais amostras do AKS, confira o site de modelos de início rápido do AKS.
Implantar o modelo
Selecione Implantar no Azure para entrar e abrir um modelo.
Na página Noções Básicas, deixe os valores padrão para Tamanho do Disco do Sistema Operacional, Contagem de Agentes, Tamanho da VM do Agente e Tipo de Sistema Operacional, e configure os seguintes parâmetros de modelo:
- Assinatura: Selecione uma assinatura do Azure.
- Grupo de recursos: Selecione Criar novo. Insira um nome exclusivo para o grupo de recursos, como myResourceGroup, e selecione OK.
- Localização: selecione um local, como Leste dos EUA.
- Nome do cluster: insira um nome exclusivo para o cluster do AKS, como myAKSCluster.
- Prefixo DNS: insira um prefixo DNS exclusivo para seu cluster, como myakscluster.
- Nome do Usuário Administrador do Linux: insira um nome de usuário para se conectar usando SSH, como azureuser.
- Origem de chave pública SSH: selecione Usar chave pública existente.
- Nome do par de chaves: copie e cole o bloco público do seu par de chaves SSH (por padrão, o conteúdo de ~/.ssh/id_rsa.pub).
Selecione Examinar + Criar>Criar.
Leva alguns minutos para o cluster do AKS ser criado. Aguarde até que o cluster seja implantado com êxito antes de passar para a próxima etapa.
Conectar-se ao cluster
Para gerenciar um cluster do Kubernetes, use o cliente de linha de comando do Kubernetes, kubectl.
Se você usar o Azure Cloud Shell, o kubectl já estará instalado. Para instalar e executar kubectl localmente, chame o comando az aks install-cli.
Configure o
kubectlpara se conectar ao cluster do Kubernetes usando o comando az aks get-credentials. Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.az aks get-credentials --resource-group myResourceGroup --name myAKSClusterVerifique a conexão com o cluster usando o comando kubectl get. Esse comando retorna uma lista dos nós de cluster.
kubectl get nodesA saída de exemplo a seguir mostra os três nós criados nas etapas anteriores. Verifique se que o status do nó é Pronto.
NAME STATUS ROLES AGE VERSION aks-agentpool-27442051-vmss000000 Ready agent 10m v1.27.7 aks-agentpool-27442051-vmss000001 Ready agent 10m v1.27.7 aks-agentpool-27442051-vmss000002 Ready agent 11m v1.27.7
Implantar o aplicativo
A fim de implantar o aplicativo, use um arquivo de manifesto para criar todos os objetos necessários para executar o Aplicativo da Loja do AKS. Um arquivo de manifesto do Kubernetes define o estado desejado de um cluster, por exemplo, as imagens de contêiner a serem executadas. O manifesto inclui as seguintes implantações e serviços do Kubernetes:
- Frente de loja: Aplicativo Web para clientes visualizarem produtos e fazerem pedidos.
- Serviço do produto: Mostra informações do produto.
- Serviço de pedido: Realiza pedidos.
- Rabbit MQ: Fila de mensagens de uma fila de pedidos.
Observação
Não é recomendável executar contêineres com estado, como o Rabbit MQ, sem armazenamento persistente para produção. Eles são usados aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como o Azure CosmosDB ou Barramento de Serviço do Azure.
Crie um arquivo chamado
aks-store-quickstart.yamle copie-o para o manifesto a seguir:apiVersion: apps/v1 kind: Deployment metadata: name: rabbitmq spec: replicas: 1 selector: matchLabels: app: rabbitmq template: metadata: labels: app: rabbitmq spec: nodeSelector: "kubernetes.io/os": linux containers: - name: rabbitmq image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine ports: - containerPort: 5672 name: rabbitmq-amqp - containerPort: 15672 name: rabbitmq-http env: - name: RABBITMQ_DEFAULT_USER value: "username" - name: RABBITMQ_DEFAULT_PASS value: "password" resources: requests: cpu: 10m memory: 128Mi limits: cpu: 250m memory: 256Mi volumeMounts: - name: rabbitmq-enabled-plugins mountPath: /etc/rabbitmq/enabled_plugins subPath: enabled_plugins volumes: - name: rabbitmq-enabled-plugins configMap: name: rabbitmq-enabled-plugins items: - key: rabbitmq_enabled_plugins path: enabled_plugins --- apiVersion: v1 data: rabbitmq_enabled_plugins: | [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0]. kind: ConfigMap metadata: name: rabbitmq-enabled-plugins --- apiVersion: v1 kind: Service metadata: name: rabbitmq spec: selector: app: rabbitmq ports: - name: rabbitmq-amqp port: 5672 targetPort: 5672 - name: rabbitmq-http port: 15672 targetPort: 15672 type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: order-service spec: replicas: 1 selector: matchLabels: app: order-service template: metadata: labels: app: order-service spec: nodeSelector: "kubernetes.io/os": linux containers: - name: order-service image: ghcr.io/azure-samples/aks-store-demo/order-service:latest ports: - containerPort: 3000 env: - name: ORDER_QUEUE_HOSTNAME value: "rabbitmq" - name: ORDER_QUEUE_PORT value: "5672" - name: ORDER_QUEUE_USERNAME value: "username" - name: ORDER_QUEUE_PASSWORD value: "password" - name: ORDER_QUEUE_NAME value: "orders" - name: FASTIFY_ADDRESS value: "0.0.0.0" resources: requests: cpu: 1m memory: 50Mi limits: cpu: 75m memory: 128Mi initContainers: - name: wait-for-rabbitmq image: busybox command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;'] resources: requests: cpu: 1m memory: 50Mi limits: cpu: 75m memory: 128Mi --- apiVersion: v1 kind: Service metadata: name: order-service spec: type: ClusterIP ports: - name: http port: 3000 targetPort: 3000 selector: app: order-service --- apiVersion: apps/v1 kind: Deployment metadata: name: product-service spec: replicas: 1 selector: matchLabels: app: product-service template: metadata: labels: app: product-service spec: nodeSelector: "kubernetes.io/os": linux containers: - name: product-service image: ghcr.io/azure-samples/aks-store-demo/product-service:latest ports: - containerPort: 3002 resources: requests: cpu: 1m memory: 1Mi limits: cpu: 1m memory: 7Mi --- apiVersion: v1 kind: Service metadata: name: product-service spec: type: ClusterIP ports: - name: http port: 3002 targetPort: 3002 selector: app: product-service --- apiVersion: apps/v1 kind: Deployment metadata: name: store-front spec: replicas: 1 selector: matchLabels: app: store-front template: metadata: labels: app: store-front spec: nodeSelector: "kubernetes.io/os": linux containers: - name: store-front image: ghcr.io/azure-samples/aks-store-demo/store-front:latest ports: - containerPort: 8080 name: store-front env: - name: VUE_APP_ORDER_SERVICE_URL value: "http://order-service:3000/" - name: VUE_APP_PRODUCT_SERVICE_URL value: "http://product-service:3002/" resources: requests: cpu: 1m memory: 200Mi limits: cpu: 1000m memory: 512Mi --- apiVersion: v1 kind: Service metadata: name: store-front spec: ports: - port: 80 targetPort: 8080 selector: app: store-front type: LoadBalancerPara obter um detalhamento dos arquivos de manifesto YAML, confira Implantações e manifestos YAML.
Se você criar e salvar o arquivo YAML localmente, poderá carregar o arquivo de manifesto no diretório padrão no CloudShell selecionando o botão Carregar/Baixar arquivos e selecionando o arquivo no sistema de arquivos local.
Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.
kubectl apply -f aks-store-quickstart.yamlA saída de exemplo a seguir mostra as implantações e os serviços:
deployment.apps/rabbitmq created service/rabbitmq created deployment.apps/order-service created service/order-service created deployment.apps/product-service created service/product-service created deployment.apps/store-front created service/store-front created
Testar o aplicativo
Verifique o status dos pods implantados usando o comando kubectl get pods. Faça com que todos os pods estejam
Runningantes de continuar.kubectl get podsVerifique se há um endereço IP público para o aplicativo de store-front. Monitore o andamento usando o comando kubectl get service com o argumento
--watch.kubectl get service store-front --watchA saída EXTERNAL-IP do serviço
store-frontserá mostrada inicialmente como pendente:NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE store-front LoadBalancer 10.0.100.10 <pending> 80:30025/TCP 4h4mQuando o endereço EXTERNAL-IP for alterado de pendente para um endereço IP público real, use
CTRL-Cpara interromper o processo de inspeção dokubectl.A seguinte saída de exemplo mostra um endereço IP público válido atribuído ao serviço:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE store-front LoadBalancer 10.0.100.10 20.62.159.19 80:30025/TCP 4h5mAbra um navegador da Web no endereço IP externo do serviço para conferir o aplicativo do Microsoft Azure Store em ação.
Excluir o cluster
Se você não planeja seguir o tutorial do AKS, limpe os recursos desnecessários para evitar cobranças do Azure.
Remova o grupo de recursos, o serviço de contêiner e todos os recursos relacionados chamando o comando az group delete.
az group delete --name myResourceGroup --yes --no-wait
Observação
O cluster do AKS foi criado com uma identidade gerenciada atribuída pelo sistema, que é a opção de identidade padrão usada neste início rápido. A plataforma gerencia essa identidade para que você não precise removê-la manualmente.
Próximas etapas
Neste início rápido, você implantou um cluster do Kubernetes e um simples aplicativo com vários contêineres. Esse aplicativo de exemplo é apenas para fins de demonstração e não representa todas as melhores práticas para aplicativos do Kubernetes. Para obter diretrizes sobre como criar soluções completas com o AKS para produção, consulte Diretrizes sobre a solução AKS.
Para saber mais sobre o AKS e percorrer um código completo de exemplo de implantação, prossiga para o tutorial de cluster do Kubernetes.
Azure Kubernetes Service