(PRETERIDO) Implantar um cluster Kubernetes para os contêineres do Linux

Neste início rápido, um cluster do Kubernetes é implantado com a CLI do Azure. Em seguida, um aplicativo com vários contêineres, composto por um front-end na Web e uma instância Redis, é executado no cluster. Depois de concluído, o aplicativo pode ser acessado pela internet.

O exemplo de aplicativo usado neste documento é escrito em Python. Os conceitos e as etapas detalhadas aqui podem ser usadas para implantar uma imagem de contêiner em um cluster Kubernetes. O código, Dockerfile e arquivos de manifesto do Kubernetes criados previamente relacionados a este projeto estão disponíveis no GitHub.

Este início rápido pressupõe uma compreensão básica dos conceitos de Kubernetes; para saber mais sobre Kubernetes, consulte a documentação do Kubernetes.

Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

Azure Cloud Shell

O Azure hospeda o Azure Cloud Shell, um ambiente de shell interativo que pode ser usado por meio do navegador. É possível usar o bash ou o PowerShell com o Cloud Shell para trabalhar com os serviços do Azure. É possível usar os comandos pré-instalados do Cloud Shell para executar o código neste artigo, sem precisar instalar nada no seu ambiente local.

Para iniciar o Azure Cloud Shell:

Opção	Exemplo/Link
Selecione Experimentar no canto superior direito de um bloco de código ou de comando. Selecionar Experimentar não copia automaticamente o código nem o comando para o Cloud Shell.
Acesse https://shell.azure.com ou selecione o botão Iniciar o Cloud Shell para abri-lo no navegador.
Selecione o botão Cloud Shell na barra de menus no canto superior direito do portal do Azure.

Para usar o Azure Cloud Shell:

1. Inicie o Cloud Shell.

2. Selecione o botão Copiar em um bloco de código (ou bloco de comando) para copiar o código ou o comando.

3. Cole o código ou comando na sessão do Cloud Shell selecionando Ctrl+Shift+V no Windows e no Linux, ou selecionando Cmd+Shift+V no macOS.

4. Pressione Enter para executar o código ou comando.

Se você optar por instalar e usar a CLI localmente, este guia de início rápido exigirá a execução da CLI do Azure versão 2.0.4 ou posterior. Execute az --version para encontrar a versão. Se você precisar instalar ou atualizar, confira Instalar a CLI do Azure.

Criar um grupo de recursos

Crie um grupo de recursos com o comando az group create. Um grupo de recursos do Azure é um grupo lógico no qual os recursos do Azure são implantados e gerenciados.

O seguinte exemplo cria um grupo de recursos chamado myResourceGroup no local westeurope.

az group create --name myResourceGroup --location westeurope

Saída:

{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup",
  "location": "westeurope",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Criar cluster Kubernetes

Crie um cluster Kubernetes no Serviço de Contêiner do Azure com o comando az acs create. O exemplo a seguir cria um cluster denominado myK8sCluster com um nó Linux mestre e três nós de agente do Linux.

az acs create --orchestrator-type kubernetes --resource-group myResourceGroup --name myK8sCluster --generate-ssh-keys

Em alguns casos, como em uma avaliação limitada, uma assinatura do Azure terá acesso limitado aos recursos do Azure. Se a implantação falhar devido à limitação nos núcleos disponíveis, reduza a contagem de agentes padrão, adicionando --agent-count 1 ao comando az acs create.

Após alguns minutos, o comando é concluído e retorna informações formatadas em json sobre o cluster.

Conectar-se ao cluster

Para gerenciar um cluster Kubernetes, use kubectl, o cliente de linha de comando Kubernetes.

Se você estiver usando o Azure Cloud Shell, o kubectl já estará instalado. Se você deseja instalá-lo localmente, pode usar o comando az acs kubernetes install-cli.

Para configurar o kubectl e se conectar ao cluster Kubernetes, execute o comando az acs kubernetes get-credentials. Esta etapa baixa credenciais e configura a CLI de Kubernetes para usá-las.

az acs kubernetes get-credentials --resource-group=myResourceGroup --name=myK8sCluster

Para verificar a conexão com o cluster, use o comando kubectl get para retornar uma lista dos nós de cluster.

kubectl get nodes

Saída:

NAME                    STATUS                     AGE       VERSION
k8s-agent-14ad53a1-0    Ready                      10m       v1.6.6
k8s-agent-14ad53a1-1    Ready                      10m       v1.6.6
k8s-agent-14ad53a1-2    Ready                      10m       v1.6.6
k8s-master-14ad53a1-0   Ready,SchedulingDisabled   10m       v1.6.6

Executar o aplicativo

Um arquivo de manifesto Kubernetes define um estado desejado para o cluster, incluindo as imagens de contêiner que devem estar em execução. Neste exemplo, um manifesto é usado para criar todos os objetos necessários para executar o aplicativo Azure Vote.

Crie um arquivo chamado azure-vote.yml e copie no YAML a seguir. Se você estiver trabalhando no Azure Cloud Shell, esse arquivo poderá ser criado usando o vi ou Nano, como se estivesse trabalhando em um sistema físico ou virtual.

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: azure-vote-back
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: azure-vote-back
    spec:
      containers:
      - name: azure-vote-back
        image: redis
        ports:
        - containerPort: 6379
          name: redis
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-back
spec:
  ports:
  - port: 6379
  selector:
    app: azure-vote-back
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: azure-vote-front
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: azure-vote-front
    spec:
      containers:
      - name: azure-vote-front
        image: microsoft/azure-vote-front:v1
        ports:
        - containerPort: 80
        env:
        - name: REDIS
          value: "azure-vote-back"
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-front
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: azure-vote-front

Use o comando kubectl create para executar o aplicativo.

kubectl create -f azure-vote.yml

Saída:

deployment "azure-vote-back" created
service "azure-vote-back" created
deployment "azure-vote-front" created
service "azure-vote-front" created

Testar o aplicativo

Conforme o aplicativo é executado, um serviço Kubernetes é criado para expor o front-end do aplicativo à Internet. A conclusão desse processo pode levar alguns minutos.

Para monitorar o andamento, use o comando kubectl get service com o argumento --watch.

kubectl get service azure-vote-front --watch

Inicialmente o EXTERNAL -IP para o serviço azure-vote-front aparece como pendente. Depois que o endereço EXTERNAL -IP foi alterado de pendente para endereço IP, use CTRL-C para interromper o processo kubectl watch.

azure-vote-front   10.0.34.242   <pending>     80:30676/TCP   7s
azure-vote-front   10.0.34.242   52.179.23.131   80:30676/TCP   2m

Agora você pode navegar para o endereço IP externo a fim de ver o aplicativo Azure Vote.

Excluir cluster

Quando o cluster não for mais necessário, você poderá usar o comando az group delete para remover o grupo de recursos, o serviço de contêiner e todos os recursos relacionados.

az group delete --name myResourceGroup --yes --no-wait

Obter o código

Neste guia de início rápido, foram usadas imagens de contêiner criadas previamente para criar uma implantação de Kubernetes. O código do aplicativo relacionado, o Dockerfile e o arquivo de manifesto Kubernetes estão disponíveis no GitHub.

https://github.com/Azure-Samples/azure-voting-app-redis

Próximas etapas

Neste início rápido, você implantou um cluster Kubernetes e um aplicativo de com vários contêineres nele.

Para saber mais sobre o Serviço de Contêiner do Azure e percorrer um código completo de exemplo de implantação, prossiga para o tutorial de cluster Kubernetes.