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

Observação

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

Este tutorial orienta você pela combinação do Kubernetes e do Docker para desenvolver e implantar um aplicativo Spring Boot no Microsoft Azure. Mais especificamente, você usa Spring Boot para desenvolvimento de aplicativos, Kubernetes para implantação de contêiner e do Serviço Kubernetes do Azure (AKS) 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 do Azure; se você ainda não tiver uma assinatura do Azure, poderá ativar seus benefícios de assinante do MSDN ou se inscrever para uma conta gratuita do Azure .
• O Azure Command-Line Interface (CLI).
• Um Java Development Kit (JDK) suportado. Para obter mais informações sobre os JDKs disponíveis para uso ao desenvolver no Azure, consulte suporte Java no Azure e Azure Stack.
• A ferramenta de construção Maven do Apache (Versão 3).
• Cliente Git.
• Cliente Docker .
• O auxiliar de credenciais do Docker 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 Spring Boot no Docker Getting Started

As etapas a seguir o orientam na criação de um aplicativo Web Spring Boot e no teste local.

1. Abra um prompt de comando e crie um diretório local para armazenar seu aplicativo e mude para esse diretório; Por exemplo:

   mkdir C:\SpringBoot
   cd C:\SpringBoot
   

   -- ou --

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

2. Clone o Spring Boot no Docker Getting Started projeto de exemplo no 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 criar e executar o aplicativo de exemplo.

   mvn package spring-boot:run
   

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

   curl http://localhost:8080
   

6. Você verá a seguinte mensagem exibida: Hello Docker World

   

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

1. Abra um prompt de comando.

2. Inicie sessão na sua conta do Azure:

   az login
   

3. Escolha 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 privado do Azure no grupo de recursos. O tutorial envia o aplicativo de exemplo como uma imagem do Docker para este registro em etapas posteriores. Substitua wingtiptoysregistry por um nome exclusivo para o seu registo.

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

Envie seu aplicativo para o registro de contêiner via Jib

1. Inicie sessão no seu Registo de Contentor 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 de <properties> no arquivo pom.xml com o nome do registo do Azure Container Registry 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 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 Microsoft Container Registry (MCR): mcr.microsoft.com/openjdk/jdk:11-ubuntu, que contém um JDK para Azure oficialmente suportado. Para outras imagens de 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 até o diretório de projeto concluído para seu aplicativo Spring Boot e execute o seguinte comando para criar a imagem e enviar 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 az acr login é válida por 1 hora. Se vir um erro 401 Unauthorized, pode executar o comando az acr login --name <your registry name> novamente para voltar a autenticar. Se vir um erro Read timed out, pode tentar aumentar os tempos limite com mvn -Djib.httpTimeout=7200000 jib:dockerBuildou -Djib.httpTimeout=0 para um tempo limite infinito.

Criar um cluster Kubernetes no AKS usando a CLI do Azure

1. Crie um cluster Kubernetes no Serviço Kubernetes do Azure. O comando a seguir cria um cluster kubernetes no grupo de recursos wingtiptoys-kubernetes, com wingtiptoys-akscluster como o nome do cluster, com o 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
   

   Este comando pode demorar um pouco para ser concluído.

2. Instale kubectl usando a CLI do Azure. Os usuários do Linux podem ter que prefixar esse comando com sudo uma vez que ele implanta a CLI do Kubernetes para /usr/local/bin.

   az aks install-cli
   

3. Baixe as informações de configuração do cluster para que você possa gerenciar seu cluster a partir da interface da Web do Kubernetes e kubectl.

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

Implantar a imagem no cluster do Kubernetes

Este tutorial implanta o aplicativo usando kubectle, em seguida, 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 do Kubernetes usando o comando kubectl run. Dê um nome de serviço para seu aplicativo no Kubernetes e o nome completo da imagem. 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 o servidor de login 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:

   • 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 voltada para o público de 80. Você acessa o aplicativo nesta porta.

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

4. Depois que o aplicativo for implantado 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}'
   

   

Implantar através da visualização de recursos do Kubernetes

1. Selecione Adicionar em qualquer uma das exibições de recursos (Namespace, Cargas de trabalho, Serviços e ingressos, Armazenamento ou Configuração).

   

2. Cole no YAML seguinte.

   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 YAML para implantar o aplicativo.

   

   Depois de implantar o Deployment, tal como acima, selecione Adicionar no fundo 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 é adicionado, o visualizador de recursos mostra seu aplicativo Spring Boot. O serviço externo inclui um endereço IP externo vinculado para que você possa visualizar facilmente o aplicativo em seu navegador.

   

   

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

   

Próximos passos

Para saber mais sobre o Spring e o Azure, continue para o centro de documentação do Spring on Azure.

Primavera no Azure

Ver também

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

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

Para obter mais informações sobre como usar o Azure com Java, consulte o Azure for Java Developers e o Trabalhando com o Azure DevOps e o Java.

Para obter mais informações sobre como implantar um aplicativo Java no Kubernetes com o Visual Studio Code, consulte Visual Studio Code Java Tutorials.

Para obter mais informações sobre o projeto de exemplo Spring Boot no Docker, consulte Spring Boot on Docker Getting Started.

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

• Para obter mais informações sobre como criar um aplicativo Spring Boot simples, consulte o Spring Initializr em https://start.spring.io/.

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

• Introdução a um cluster Kubernetes no Serviço Kubernetes do Azure

Mais informações sobre como utilizar a interface de linha de comando do Kubernetes estão disponíveis no guia do utilizador do kubectl em https://kubernetes.io/docs/reference/kubectl/.

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

• Configurando contas de serviço para Pods
• Namespaces
• Extraindo uma imagem de um registro privado

Para obter exemplos adicionais de como usar imagens personalizadas do Docker com o Azure, consulte Usando uma imagem personalizada do Docker para o Azure Web App no Linux.

Para obter mais informações sobre como executar e depurar iterativamente contentores diretamente no Azure Kubernetes Service (AKS) com o Azure Dev Spaces, consulte Introdução aos Espaços de Desenvolvimento do Azure com Java