Implantar o aplicativo Spring Boot para Serviço de Kubernetes do Azure

Observação

Para aplicações Spring Boot, use o Aplicativos de Contêiner do Azure. No entanto, você ainda pode usar o Serviço de Kubernetes do Azure como um destino. Para obter mais informações, consulte Escolha os serviços ideais do Azure para seus aplicativos Java.

Este tutorial mostra como usar o Kubernetes e o Docker para desenvolver e implantar um aplicativo Spring Boot para Microsoft Azure. Mais especificamente, você usa spring boot para desenvolvimento de aplicativos, do Kubernetes para implantação de contêiner e do AKS (Serviço de Kubernetes do Azure) para hospedar seu aplicativo.

Kubernetes e Docker são soluções de código aberto que ajudam os desenvolvedores a automatizar a implantação, o dimensionamento e o gerenciamento de seus aplicativos executados em contêineres.

Pré-requisitos

• Uma assinatura Azure; se você ainda não tiver uma assinatura Azure, ative os benefícios do assinante do MSDN ou inscreva-se para uma conta de Azure gratuita.
• 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 e crie um diretório local para manter seu aplicativo e altere para esse 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á, Docker World

   

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

1. Abra um prompt de comando.

2. Entre na sua conta do Azure:

   az login
   

3. Selecione sua assinatura de 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 carrega o aplicativo de exemplo como uma imagem do Docker para esse registrador em etapas seguintes. Substitua wingtiptoysregistry por um nome exclusivo para o registro.

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

Faça push do seu aplicativo para o registro de contêiner usando o Jib

1. Entre no Registro de Contêiner do Azure usando a 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, como 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. Use uma imagem base do MCR (Registro de Contêiner Microsoft): mcr.microsoft.com/openjdk/jdk:11-ubuntu, que contém um JDK com suporte oficial para Azure. Para outras imagens base do MCR com JDKs com suporte oficial, 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. Vá para o diretório de projeto concluído para seu aplicativo Spring Boot e execute o seguinte comando para criar a imagem e efetuar push da imagem para o registro:

   az acr login && mvn compile jib:build
   

Observação

Por motivos de segurança, a credencial criada usando az acr login é válida por uma hora. Se você vir um 401 Unauthorized erro, execute o az acr login --name <your registry name> comando novamente para reautenticar. Se você vir um Read timed out erro, tente aumentar os tempos limite com mvn -Djib.httpTimeout=7200000 jib:dockerBuild, ou use -Djib.httpTimeout=0 para um tempo limite infinito.

Criar um cluster do Kubernetes no AKS usando o CLI do Azure

1. Criar um cluster Kubernetes no Serviço de Kubernetes do Azure. O comando a seguir cria um cluster kubernetes no wingtiptoys-kubernetes grupo de recursos, com wingtiptoys-akscluster como o nome do cluster, com Registro de Contêiner do Azure (ACR) wingtiptoysregistry anexado e 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 do Linux talvez precisem preceder este comando com sudo, pois ele instala 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 kubectle, em seguida, você pode explorar 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:

   • Especifique o nome gs-spring-boot-docker do contêiner imediatamente após o run comando.

   • O --image parâmetro especifica o servidor de logon combinado e o 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:

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

   • 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. Depois de implantar o aplicativo no cluster, consulte o endereço IP externo e abra-o no 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 na etapa anterior, 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 de adicionar o arquivo YAML, o visualizador de recursos mostrará seu 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. 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, consulte o Azure para Desenvolvedores em Java e o Trabalhando com o Azure DevOps e Java.

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 obter mais informações sobre o projeto de exemplo Spring Boot no Docker, consulte 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 o Kubernetes com Azure:

• Introdução ao cluster Kubernetes no Serviço Azure Kubernetes

Para obter mais informações sobre como usar a interface de linha de comando do Kubernetes, consulte o 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 de como usar imagens personalizadas do Docker com Azure, consulte Usando uma imagem personalizada do Docker para Azure Aplicativo Web no Linux.

Para obter mais informações sobre a execução iterativa e a depuração de contêineres diretamente no AKS (Serviço de Kubernetes do Azure) com Azure Dev Spaces, consulte Introdução ao Azure Dev Spaces com Java.