Guia de início rápido: implantar um cluster do Serviço Kubernetes do Azure (AKS) usando um modelo ARM
O Serviço Kubernetes do Azure (AKS) é um serviço Kubernetes gerenciado que permite implantar e gerenciar clusters rapidamente. Neste início rápido, irá:
- Implante um cluster AKS usando um modelo do Azure Resource Manager.
- Execute 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 utiliza sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.
Nota
Para começar a provisionar rapidamente um cluster AKS, este artigo inclui etapas para implantar um cluster com configurações padrão apenas 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 ela 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, consulte Conceitos principais do Kubernetes para o Serviço Kubernetes do Azure (AKS).
-
Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.
Verifique se a identidade usada para criar o cluster tem as permissões mínimas apropriadas. Para obter mais detalhes sobre acesso e identidade para AKS, consulte Opções de acesso e identidade para o Serviço Kubernetes do Azure (AKS).
Para implantar um modelo ARM, você precisa de acesso de gravação nos recursos que está implantando e acesso a todas as operações no
Microsoft.Resources/deploymentstipo de recurso. Por exemplo, para implantar uma máquina virtual, você precisa deMicrosoft.Compute/virtualMachines/writepermissõesMicrosoft.Resources/deployments/*. Para obter uma lista de funções e permissões, veja Funções incorporadas 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, consulte Guia de início rápido para Bash no Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.
Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Entrar com a CLI do Azure.
Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.
Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando 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 AKS usando um modelo ARM, forneça uma chave pública SSH. Se você precisar desse recurso, siga as etapas nesta seção. Caso contrário, vá para a seção Revisar o modelo .
Para acessar os nós AKS, você se conecta usando um par de chaves SSH (público e privado). Para criar um par de chaves SSH:
Vá para https://shell.azure.com abrir o Cloud Shell no seu navegador.
Crie um par de chaves SSH usando o comando az sshkey create ou o
ssh-keygencomando.# 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 az sshkey create comando ou ssh-keygen substituirá qualquer par de chaves SSH existente com o mesmo nome.
Para obter mais informações sobre como criar chaves SSH, consulte Criar e gerenciar chaves SSH para autenticação no Azure.
Rever o modelo
O modelo utilizado neste início rápido pertence aos 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.9.1.41621",
"templateHash": "2637152180661081755"
}
},
"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,
"maxValue": 1023,
"minValue": 0,
"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,
"maxValue": 50,
"minValue": 1,
"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": "2022-05-02-preview",
"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'))).fqdn]"
}
}
}
O tipo de recurso definido no modelo ARM é Microsoft.ContainerService/managedClusters.
Para obter mais exemplos do AKS, consulte o site de modelos de início rápido do AKS.
Implementar 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 GB de tamanho de 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:
- Subscrição: selecione uma subscrição 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 East US.
- Nome do cluster: insira um nome exclusivo para o cluster AKS, como myAKSCluster.
- Prefixo DNS: insira um prefixo DNS exclusivo para seu cluster, como myakscluster.
- Linux Admin Username: insira um nome de usuário para se conectar usando SSH, como azureuser.
- Origem da chave pública SSH: Selecione Usar chave pública existente.
- Nome do par de chaves: copie e cole a parte pública do seu par de chaves SSH (por padrão, o conteúdo de ~/.ssh/id_rsa.pub).
Selecione Rever + Criar>Criar.
A criação do cluster do AKS demora alguns minutos. Aguarde até que o cluster seja implantado com êxito antes de passar para a próxima etapa.
Ligar ao cluster
Para gerenciar um cluster Kubernetes, use o cliente de linha de comando Kubernetes, kubectl.
Se você usa o Azure Cloud Shell, kubectl já está instalado. Para instalar e executar kubectl localmente, chame o comando az aks install-cli .
Configure
kubectlpara se conectar ao cluster do Kubernetes usando o comando az aks get-credentials . Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.az aks get-credentials --resource-group myResourceGroup --name myAKSClusterVerifique a conexão com seu cluster usando o comando kubectl get . Este comando retorna uma lista dos nós do cluster.
kubectl get nodesA saída de exemplo a seguir mostra os três nós criados nas etapas anteriores. Verifique se 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
Implementar a aplicação
Para implantar o aplicativo, use um arquivo de manifesto para criar todos os objetos necessários para executar o aplicativo AKS Store. Um arquivo de manifesto do Kubernetes define o estado desejado de um cluster, como quais imagens de contêiner devem ser executadas. O manifesto inclui as seguintes implantações e serviços do Kubernetes:
- Vitrine: aplicativo Web para que os clientes visualizem produtos e façam pedidos.
- Serviço do produto: Mostra as informações do produto.
- Serviço de pedidos: Faz pedidos.
- Rabbit MQ: Fila de mensagens para uma fila de pedidos.
Nota
Não recomendamos a execução de contêineres com monitoração de 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 o Azure Service Bus.
Crie um arquivo nomeado
aks-store-quickstart.yamle copie no seguinte manifesto: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, consulte Implantações e manifestos YAML.
Se você criar e salvar o arquivo YAML localmente, poderá carregar o arquivo de manifesto para seu diretório padrão no CloudShell selecionando o botão Upload/Download de arquivos e selecionando o arquivo do seu sistema de arquivos local.
Implante o aplicativo usando o comando kubectl apply e especifique o nome do seu 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 a aplicação
Verifique o status dos pods implantados usando o comando kubectl get pods . Faça com que todos os pods estejam
Runningantes de prosseguir.kubectl get podsVerifique se há um endereço IP público para o aplicativo de vitrine. Monitore o progresso usando o comando kubectl get service com o
--watchargumento.kubectl get service store-front --watchA saída EXTERNAL-IP para o
store-frontserviço inicialmente mostra 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 mudar de pendente para um endereço IP público real, use
CTRL-Cpara interromper okubectlprocesso de monitoramento.A saída de exemplo a seguir 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 seu serviço para ver o aplicativo da Loja Azure em ação.
Eliminar o cluster
Se você não planeja passar pelo tutorial do AKS, limpe 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
Nota
O cluster AKS foi criado com uma identidade gerenciada atribuída ao 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óximos passos
Neste início rápido, você implantou um cluster Kubernetes e, em seguida, implantou um aplicativo simples de vários contêineres nele. Este aplicativo de exemplo é apenas para fins de demonstração e não representa todas as práticas recomendadas para aplicativos Kubernetes. Para obter orientação sobre como criar soluções completas com o AKS para produção, consulte Orientação de solução AKS.
Para saber mais sobre o AKS e percorrer um exemplo completo de código para implantação, continue para o tutorial do cluster do Kubernetes.