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

Observação

Para aplicativos Spring Boot, recomendamos usar os Aplicativos Spring do Azure. No entanto, você ainda pode optar por usar o Serviço de Kubernetes do Azure como um destino. Para obter mais informações, consulte Escolher os serviços do Azure certos para seus aplicativos Java.

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.

Observação

Devido aos requisitos de virtualização deste tutorial, você não pode seguir as etapas neste artigo em uma máquina virtual. Você deve usar um computador físico com recursos de virtualização habilitados.

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
   

Observação

Devido à preocupação de segurança da Cli do Azure e do Registro de Contêiner do Azure, a credencial criada por é válida por az acr login 1 hora. Se você vir um erro 401 não autorizado , poderá executar o az acr login --name <your registry name> comando novamente para autenticar novamente. Se você vir um erro de Tempo limite de leitura, poderá tentar aumentar os tempos limite com mvn -Djib.httpTimeout=7200000 jib:dockerBuildo , ou -Djib.httpTimeout=0 para um tempo limite infinito.

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.

Spring no 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