Implantar um aplicativo Spring Boot no Serviço de Kubernetes do Azure

Este tutorial explica como combinar o Kubernetes e o Docker para desenvolver e implantar um aplicativo Spring Boot no Microsoft Azure. Mais especificamente, você usa o Spring Boot para o desenvolvimento de aplicativos, o Kubernetes para a implantação de contêineres e o AKS (Serviço de Kubernetes do Azure) para hospedar seu aplicativo.

O Kubernetes e o Docker são soluções de software livre que ajudam os desenvolvedores a automatizar a implantação, o dimensionamento e o gerenciamento de seus aplicativos em execução em contêineres.

Pré-requisitos

• Uma assinatura do Azure; se ainda não tiver uma assinatura do Azure, você poderá ativar o benefício de assinante do MSDN ou inscrever-se para uma conta gratuita do Azure.
• ACLI (interface de linha de comando) do Azure.
• Um JDK (Java Development Kit) com suporte. Para obter mais informações sobre os JDKs disponíveis para uso durante o desenvolvimento no Azure, confira Suporte a Java no Azure e no Azure Stack.
• A ferramenta de compilação Maven do Apache (Versão 3).
• Um cliente Git.
• Um cliente do Docker.
• O auxiliar de credencial do Docker do ACR.

Criar o aplicativo Web de Introdução ao Spring Boot no Docker

As etapas a seguir mostram como compilar um aplicativo Web Spring Boot e testá-lo localmente.

1. Abra um prompt de comando, crie um diretório local para conter o aplicativo e altere para o diretório. Por exemplo:

   mkdir C:\SpringBoot
   cd C:\SpringBoot
   

   -- ou --

   mkdir /users/$USER/SpringBoot
   cd /users/$USER/SpringBoot
   

2. Clone o exemplo de projeto Introdução ao Spring Boot no Docker para o diretório.

   git clone https://github.com/spring-guides/gs-spring-boot-docker.git
   

3. Altere o diretório para o projeto concluído.

   cd gs-spring-boot-docker
   cd complete
   

4. Use o Maven para compilar e executar o aplicativo de exemplo.

   mvn package spring-boot:run
   

5. Teste o aplicativo Web navegando até http://localhost:8080 ou com o seguinte comando curl:

   curl http://localhost:8080
   

6. Você verá a seguinte mensagem exibida: Olá, mundo do Docker

   

Criar um Registro de Contêiner do Azure usando a CLI do Azure

1. Abra um prompt de comando.

2. Faça logon na sua Conta do Azure:

   az login
   

3. Escolha a sua Assinatura do Azure:

   az account set -s <YourSubscriptionID>
   

4. Crie um grupo de recursos para os recursos do Azure usados neste tutorial.

   az group create --name=wingtiptoys-kubernetes --location=eastus
   

5. Crie um registro de contêiner do Azure privado no grupo de recursos. O tutorial envia o aplicativo de exemplo para esse registro como uma imagem de Docker em etapas posteriores. Substitua wingtiptoysregistry por um nome exclusivo para o registro.

   az acr create --resource-group wingtiptoys-kubernetes --location eastus \
    --name wingtiptoysregistry --sku Basic
   

Enviar por push seu aplicativo para o registro de contêiner via Jib

1. Faça logon no Registro de Contêiner do Azure a partir da CLI do Azure.

   # set the default name for Azure Container Registry, otherwise you need to specify the name in "az acr login"
   az config set defaults.acr=wingtiptoysregistry
   az acr login
   

2. Abra o arquivo pom.xml com um editor de texto, por exemplo, Visual Studio Code.

   code pom.xml
   

3. Atualize a coleção <properties> no arquivo pom.xml com o nome de registro do Registro de Contêiner do Azure e a versão mais recente do jib-maven-plugin.

   <properties>
      <!-- Note: If your ACR name contains upper case characters, be sure to convert them to lower case characters. -->
      <docker.image.prefix>wingtiptoysregistry.azurecr.io</docker.image.prefix>
      <jib-maven-plugin.version>2.5.2</jib-maven-plugin.version>
      <java.version>1.8</java.version>
   </properties>
   

4. Atualize a coleção <plugins> no arquivo de pom.xml para que o elemento <plugin> contenha uma entrada para o jib-maven-plugin, conforme mostrado no exemplo a seguir. Observe que estamos usando uma imagem base do MCR (Registro de Contêiner da Microsoft): mcr.microsoft.com/openjdk/jdk:11-ubuntu, que contém um JDK oficialmente compatível para o Azure. Para outras imagens base MCR com JDKs oficialmente suportados, consulte Instalar o Microsoft Build do OpenJDK..

   <plugin>
     <artifactId>jib-maven-plugin</artifactId>
     <groupId>com.google.cloud.tools</groupId>
     <version>${jib-maven-plugin.version}</version>
     <configuration>
        <from>
            <image>mcr.microsoft.com/openjdk/jdk:11-ubuntu</image>
        </from>
        <to>
            <image>${docker.image.prefix}/gs-spring-boot-docker</image>
        </to>
     </configuration>
   </plugin>
   

5. Navegue para o diretório do projeto completo de seu aplicativo Spring Boot, execute o seguinte comando para compilar a imagem e envie por push a imagem para o registro:

   az acr login && mvn compile jib:build
   

Criar um Cluster Kubernetes no AKS usando a CLI do Azure

1. Criar um cluster Kubernetes no Serviço de Kubernetes do Azure. O seguinte comando cria um cluster kubernetes no grupo de recursos wingtiptoys-kubernetes, com wingtiptoys-akscluster como o nome do cluster, com o ACR (Registro de Contêiner do Azure) wingtiptoysregistry anexado e com wingtiptoys-kubernetes como o prefixo DNS:

   az aks create --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster \
    --attach-acr wingtiptoysregistry \
    --dns-name-prefix=wingtiptoys-kubernetes --generate-ssh-keys
   

   Esse comando pode demorar algum tempo para ser concluído.

2. Instalar kubectl usando a CLI do Azure. Os usuários de Linux podem ter que prefixar esse comando com sudo, já que ele implanta a CLI do Kubernetes em /usr/local/bin.

   az aks install-cli
   

3. Baixe as informações de configuração do cluster para que possa gerenciá-lo na interface da Web do Kubernetes e kubectl.

   az aks get-credentials --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster
   

Implantar a imagem em seu cluster Kubernetes

Este tutorial implanta o aplicativo usando kubectl e então permite que você explore a implantação por meio da interface da Web do Kubernetes.

Implantar com kubectl

1. Abra um prompt de comando.

2. Execute seu contêiner no cluster Kubernetes usando o comando kubectl run. Forneça um nome de serviço para seu aplicativo no Kubernetes e o nome de imagem completo. Por exemplo:

   kubectl run gs-spring-boot-docker --image=wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

   Neste comando:

   • O nome do contêiner gs-spring-boot-docker é especificado imediatamente após o comando run

   • O parâmetro --image especifica a combinação de servidor de logon e nome da imagem como wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest

3. Exponha seu cluster Kubernetes externamente usando o comando kubectl expose. Especifique o nome do serviço, a porta TCP voltada para o público usada para acessar o aplicativo e a porta de destino interna na qual seu aplicativo escuta. Por exemplo:

   kubectl expose pod gs-spring-boot-docker --type=LoadBalancer --port=80 --target-port=8080
   

   Neste comando:

   • O nome do contêiner gs-spring-boot-docker é especificado imediatamente após o comando expose pod.

   • O parâmetro --type especifica que o cluster usa o balanceador de carga.

   • O parâmetro --port especifica a porta TCP 80 voltada para o público. Você acessa o aplicativo nessa porta.

   • O parâmetro --target-port especifica a porta TCP interna 8080. O balanceador de carga encaminha solicitações ao seu aplicativo nesta porta.

4. Após a implantação do aplicativo no cluster, consulte o endereço IP externo e abra-o em seu navegador da Web:

   kubectl get services -o=jsonpath='{.items[*].status.loadBalancer.ingress[0].ip}'
   

   

Implantação com a exibição de recursos do Kubernetes

1. Selecione Adicionar de qualquer uma das exibições de recursos (namespace, cargas de trabalho, serviços e entradas, armazenamento ou configuração).

   

2. Cole o seguinte YAML:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gs-spring-boot-docker
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gs-spring-boot-docker
     template:
       metadata:
         labels:
           app: gs-spring-boot-docker
       spec:
         containers:
         - name: gs-spring-boot-docker
           image: wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

3. Selecione Adicionar na parte inferior do editor de YAML para implantar o aplicativo.

   

   Depois de implantar o Deployment, assim como acima, selecione Adicionar na parte inferior do editor YAML para implantar Service usando o seguinte YAML:

   apiVersion: v1
   kind: Service
   metadata:
     name: gs-spring-boot-docker
   spec:
     type: LoadBalancer
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: gs-spring-boot-docker
   

4. Depois que o arquivo YAML for adicionado, o visualizador de recursos mostrará o aplicativo Spring Boot. O serviço externo inclui um endereço IP externo vinculado para que você possa exibir facilmente o aplicativo no navegador.

   

   

5. Selecione IP externo. Em seguida, você verá seu aplicativo Spring Boot em execução no Azure.

   

Próximas etapas

Para saber mais sobre o Spring e o Azure, continue no Spring no Centro de Documentação do Azure.

Confira também

Para obter mais informações sobre como usar o Spring Boot no Azure, confira o seguinte artigo:

• Implantar um aplicativo do Spring Boot no Serviço de Aplicativo do Azure no Linux

Para obter mais informações sobre como usar o Azure com Java, confira Azure para Desenvolvedores Java e Como trabalhar com o Java e o Azure DevOps.

Para saber mais sobre como implantar um aplicativo Java para Kubernetes com o Visual Studio Code, confira Tutoriais de Java do Visual Studio Code.

Para saber mais sobre o Spring Boot no projeto de exemplo do Docker, veja Introdução ao Spring Boot no Docker.

Os links a seguir fornecem mais informações sobre como criar aplicativos Spring Boot:

• Para saber mais sobre como começar a criar um aplicativo Spring Boot simples, confira o Spring Initializr em https://start.spring.io/.

Os links a seguir fornecem mais informações sobre como usar kubernetes com o Azure:

• Comece com um cluster Kubernetes no Serviço de Kubernetes do Azure

Saiba mais sobre como usar a interface de linha de comando Kubernetes no guia do usuário kubectl em https://kubernetes.io/docs/reference/kubectl/.

O site do Kubernetes tem vários artigos que abordam o uso de imagens em registros privados:

• Configurar contas de serviço para Pods
• Namespaces
• Extrair uma imagem de um registro privado

Para obter mais exemplos sobre como usar imagens personalizadas do Docker com o Azure, veja Usando uma imagem personalizada do Docker para o Aplicativo Web do Azure no Linux.

Para obter mais informações sobre como executar iterativamente e depurar os contêineres direto no Serviço de Kubernetes do Azure (AKS) com o Azure Dev Spaces, confira Introdução ao Azure Dev Spaces com Java