Kubernetes Usando o Cloud Shell: Implantar um Aplicativo Spring Boot

Neste tutorial, você usa uma conta do Oracle Cloud Infrastructure para configurar um cluster do Kubernetes. Em seguida, você implanta um aplicativo Spring Boot no seu cluster.

As principais tarefas incluem:

  • Crie um compartimento.
  • Configurar um cluster do Kubernetes no OCI.
  • Crie um aplicativo Spring Boot e uma imagem do Docker.
  • Envie sua imagem ao OCI Container Registry.
  • Implante seu aplicativo Docker no seu cluster usando o Cloud Shell.
  • Estabelecer conexão com seu aplicativo pela internet.
Um diagrama dos componentes necessários para executar um aplicativo Spring Boot no Oracle Cloud Infrastructure Kubernetes Engine

Para obter informações adicionais, consulte:

Antes de Começar

Para executar este tutorial com sucesso, você precisa ter o seguinte:

Requisitos
Observação

A vantagem de usar o Cloud Shell é que todas as ferramentas necessárias para gerenciar seu aplicativo já estão instaladas e prontas para uso.

1. Preparar

Prepare seu ambiente para criar e implantar seu aplicativo.

Verifique seus Limites do Serviço
  1. Faça log-in na Console do Oracle Cloud Infrastructure.
  2. Abra o menu de navegação e clique em Governança e Administração. Em Governança, clique em Limites, Cotas e Uso.
  3. Localize seu limite de serviço para Regiões:
    • Filtro para as seguintes opções:
      • Serviço: Regiões
      • Escopo: Tenancy
      • Recurso: Contagem de regiões inscritas
      • Serviço: <tenancy-name> (raiz)
    • Localizar limite de serviço:
      • Nome do Limite: subscribed-region-count
      • Limite de Serviço: no mínimo 2
  4. Localize sua contagem de núcleos do serviço Compute disponível para a forma VM.Standard.E3.Flex:
    • Filtro para as seguintes opções:
      • Serviço : Compute
      • Escopo: <first-availability-domain>. Exemplo: EMlr:US-ASHBURN-AD-1
      • Recurso: Núcleos para Instâncias Standard.E3.Flex e BM.Standard.E3.128
      • Serviço: <tenancy-name> (raiz)
    • Localizar contagem de núcleos disponível:
      • Nome do Limite: standard-e3-core-ad-count
      • Disponível: no mínimo 1
    • Repita para Escopo: <second-availability-domain> e <third-availability-domain>. Cada região deve ter pelo menos um núcleo disponível para esta forma.
  5. Descubra se você tem 50 GB de Volume em Blocos disponível:
    • Filtro para as seguintes opções:
      • Serviço: Volume em Bloco
      • Escopo: <first-availability-domain>. Exemplo: EMlr:US-ASHBURN-AD-1
      • Tamanho do Volume (GB) do Recurso
      • Serviço: <tenancy-name> (raiz)
    • Localizar contagem de núcleos disponível:
      • Nome do Limite: total-storage-gb
      • Disponível: no mínimo 50
    • Repita para Escopo: <second-availability-domain> e <third-availability-domain>. Cada região deve ter pelo menos 50 GB de volume em blocos disponível.
  6. Descubra quantos Balanceadores de Carga Flexíveis você tem disponíveis:
    • Filtro para as seguintes opções:
      • Serviço: LbaaS
      • Escopo: <your-region>. Exemplo: us-ashburn-1
      • Recurso: <blank>
      • Serviço: <tenancy-name> (raiz)
    • Localizar a contagem das formas a seguir
      • Nome do Limite: lb-flexible-bandwidth-count
      • Disponível: no mínimo 1
Observação

Este tutorial cria três instâncias de computação com uma forma VM.Standard.E2.1 para os nós do cluster. Para usar outra forma, filtre sua contagem de núcleos. Por exemplo, para VM.Standard2.4, filtre Núcleos para Instâncias de VM e BM baseadas em Standard2 e obtenha a contagem.

Para obter uma lista de todas as formas, consulte Formas Padrão da VM.

Observação

Este tutorial cria três instâncias de computação com uma forma VM.Standard.E3.Flex para os nós do cluster. Para usar outra forma, filtre sua contagem de núcleos. Por exemplo, para VM.Standard2.4, filtre Núcleos para Instâncias de VM e BM baseadas em Standard2 e obtenha a contagem.

Para obter uma lista de todas as formas, consulte Formas Padrão da VM.

Observação

Este tutorial usa um workflow de 'Criação Rápida' para criar um cluster com uma sub-rede regional pública que hospede um balanceador de carga flexível. Para usar outro balanceador de carga, você pode usar um workflow personalizado para especificar explicitamente quais recursos de rede existentes devem ser usados, incluindo as sub-redes existentes nas quais os balanceadores de carga serão criados.

Para usar outra largura de banda para o balanceador de carga, filtre por sua contagem, por exemplo, Largura de banda de 100 Mbps ou Largura de banda de 400 Mbps.

Criar um Token de Autorização
  1. Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Definições do usuário ou Meu perfil, dependendo da opção exibida.
  2. Clique em Tokens de Autenticação.
  3. Clique em Gerar Token.
  4. Dê uma descrição.
  5. Clique em Gerar Token.
  6. Copie o token e salve-o.
  7. Clique emFechar.
Observação

Certifique-se de salvar seu token logo após criá-lo. Você não terá acesso a ele posteriormente.
Reunir Informações Necessárias
  1. Colete as informações de credenciais a seguir na Console do Oracle Cloud Infrastructure.
    • Nome da tenancy: <tenancy-name>
      • Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Tenancy: <your_tenancy_name>.
    • namespace da Tenancy: <tenancy-namespace>
      • Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Tenancy: <your_tenancy_name>.
      • Copie o valor do Namespace do Object Storage.
      Observação

      Para algumas contas, o nome da tenancy e o namespace diferem. Certifique-se de usar o namespace neste tutorial.
    • OCID da Tenancy: <tenancy-ocid>
      • Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Definições do usuário ou Meu perfil, dependendo da opção exibida.
      • Copiar OCID.
    • Nome do Usuário: <user-name>
      • Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Definições do usuário ou Meu perfil, dependendo da opção exibida.
    • OCID DO Usuário: <user-ocid>
      • Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Definições do usuário ou Meu perfil, dependendo da opção exibida.
      • Copiar OCID.
  2. Encontre as informações da sua região.
  3. Copie seu token de autenticação da seção Criar um Token de Autenticação.
    • Token de Autenticação: <auth-token>

2. Configurar um Cluster

Instale e configure opções de gerenciamento para seu cluster do Kubernetes. Posteriormente, implante seu aplicativo nesse cluster.

Adicionar Política de Compartimento

Se seu nome de usuário estiver no grupo Administradores, ignore esta seção. Caso contrário, peça ao administrador para adicionar a seguinte política à sua tenancy:

allow group <the-group-your-username-belongs> to manage compartments in tenancy

Com esse privilégio, você pode criar um compartimento para todos os recursos do seu tutorial.

Etapas para Adicionar a Política
  1. Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Definições do usuário ou Meu perfil, dependendo da opção exibida.
  2. No painel esquerdo, clique em Grupos.
  3. Em um bloco de notas, copie o Nome do Grupo ao qual seu nome de usuário pertence.
  4. Abra o menu de navegação e clique em Identidade e Segurança. Em Identidade, clique em Políticas.
  5. Clique em Criar Política.
  6. Preencha as informações a seguir:
    • Nome: manage-compartments
    • Descrição: Allow the group <the-group-your-username-belongs> to list, create, update, delete and recover compartments in the tenancy.
    • Compartimento: <your-tenancy>(root)
  7. Para o Criador de Política, clique em Mostrar editor manual.
  8. Cole na seguinte política:
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  9. Clique em Criar.

Referência

O tipo de recurso compartments em Verbos + Combinações Resource-Type para o Serviço IAM

Criar um Compartimento

Crie um compartimento para os recursos criados neste tutorial.

  1. Faça log-in na Console do Oracle Cloud Infrastructure.
  2. Abra o menu de navegação e clique em Identidade e Segurança. Em Identidade, clique em Compartimentos.
  3. Clique em Criar Compartimento.
  4. Preencha as informações a seguir:
    • Nome: <your-compartment-name>
    • Descrição: Compartment for <your-description>.
    • Compartimento Pai: <your-tenancy>(root)
  5. Clique em Criar Compartimento.

Referência: Criar um compartimento

Adicionar Política de Recursos

Se seu nome de usuário estiver no grupo Administradores, ignore esta seção. Caso contrário, peça ao administrador para adicionar a seguinte política à sua tenancy:

allow group <the-group-your-username-belongs> to manage all-resources in compartment <your-compartment-name>

Com esse privilégio, você pode gerenciar todos os recursos em seu compartimento, basicamente dando a você direitos administrativos nesse compartimento.

Etapas para Adicionar a Política
  1. Abra o menu de navegação e clique em Identidade e Segurança. Em Identidade, clique em Políticas.
  2. Selecione seu compartimento na lista Compartimento.
  3. Clique em Criar Política.
  4. Preencha as informações a seguir:
    • Nome: manage-<your-compartment-name>-resources
    • Descrição: Allow users to list, create, update, and delete resources in <your-compartment-name>.
    • Compartimento: <your-tenancy>(root)
  5. Para o Criador de Política, selecione as seguintes opções:
    • Casos de uso da política: Compartment Management
    • Modelos de política comum: Let compartment admins manage the compartment
    • Grupos: <the-group-your-username-belongs>
    • Localidade: <your-tenancy>(root)
  6. Clique em Criar.

Referência

Políticas Comuns

Criar um Cluster com 'Criação Rápida'

Crie um cluster com definições padrão e novos recursos de rede por meio do workflow 'Criação Rápida'.

  1. Acesse a Console do Oracle Cloud Infrastructure.
  2. Abra o menu de navegação e clique em Serviços ao Desenvolvedor. Em Contêineres e Artefatos, clique em Clusters do Kubernetes (OKE).
  3. Clique em Criar Cluster.
  4. Selecione Criação Rápida.
  5. Clique em Iniciar Workflow.

    A caixa de diálogo Criar Cluster Rapidamente é exibida.

  6. Preencha as informações a seguir.
    • Nome: <your-cluster-name>
    • Compartimento: <your-compartment-name>
    • Versão do Kubernetes: <take-default>
    • Ponto Final da API Kubernetes: Ponto Final Público

      O cluster do Kubernetes é hospedado em uma sub-rede pública com um endereço IP público designado automaticamente.

    • Nós de Trabalho do Kubernetes: Nós de Trabalho Privados

      Os nós de trabalho do Kubernetes são hospedados em uma sub-rede privada.

    • Forma: VM.Standard.E3.Flex
    • Selecione o número de OCPUs: 1
    • Volume de Memória (GB): 16
    • Número de Nós: 3
    • Largura de Banda da Rede: 1.0 (Esse valor é calculado pela contagem de OCPUs.)
    • Total Máximo de VNICs: 2 (Esse valor é calculado pela contagem de OCPUs.)
  7. Clique em Mostrar Opções Avançadas.

    Mantenha os padrões.

    • Especificar um tamanho de volume de inicialização personalizado: Desmarque a caixa de seleção.
    • Verificação de Imagem: Desmarque a caixa de seleção.
    • Adicionar uma chave SSH: Nenhuma chave SSH
  8. Clique em Próximo.

    Todas as suas opções são exibidas. Revise-as para garantir que tudo esteja configurado corretamente.

  9. Clique em Criar Cluster.

    Os serviços configurados para seu cluster são exibidos.

  10. Clique em Fechar.
  11. Pegue uma xícara de café. Leva alguns minutos para o cluster ser criado.
Você criou com sucesso um cluster do Kubernetes.
Configurar o Cloud Shell para Acessar o Cluster

Depois de criar um cluster do Kubernetes, configure o Cloud Shell para acessar o cluster.

  1. Acesse a Console do Oracle Cloud Infrastructure.
  2. Abra o menu de navegação e clique em Serviços ao Desenvolvedor. Em Contêineres e Artefatos, clique em Clusters do Kubernetes (OKE).
  3. Clique no link para <your-cluster>.

    As informações sobre o seu cluster são exibidas.

  4. Clique em Acessar Cluster.
  5. Clique em Acesso do Cloud Shell. Siga as etapas na caixa de diálogo. As etapas a seguir são fornecidas para sua referência.
  6. Clique em Iniciar Cloud Shell. Como alternativa, no menu principal, você pode clicar no ícone do Cloud Shell (cloud-shell-icon) e iniciar uma sessão.
  7. Verifique sua versão da CLI oci e verifique se o Cloud Shell está funcionando.
    oci -v
  8. Crie o arquivo kubeconfig para sua configuração. Use as informações da caixa de diálogo Acessar Seu Cluster.
    oci ce cluster create-kubeconfig <use data from dialog>
    Você recebe uma mensagem que:
    New config written to the Kubeconfig file <your-home-directory>/.kube/config
    Observação

    Se o arquivo config não estiver armazenado em seu local padrão (~/.kube/config, você deverá exportar a variável de ambiente KUBECONFIG a fim de que ela aponte para o local.
    export KUBECONFIG=$HOME/<new-location>/config
    Observação

    Ao trabalhar com mais de um cluster, você especifica um arquivo de configuração específico na linha de comando. Exemplo:
    kubectl --kubeconfig=</path/to/config/file> <some-command>
  9. Teste a configuração do cluster com o comando a seguir.

    Listar clusters:

    kubectl get service

Com a configuração de acesso ao cluster, agora você está pronto para preparar seu aplicativo para implantação.

3. Criar seu Aplicativo Docker

Crie um aplicativo local e uma imagem do Docker para o aplicativo.

Criar um Aplicativo Local
  1. Confira o guia Spring Boot Docker com o Git:
    git clone https://github.com/spring-guides/gs-spring-boot-docker.git
  2. Passe para o diretório gs-spring-boot-docker/initial.
    cd gs-spring-boot-docker/initial
  3. Passe para o diretório de origem Java: src/main/java/hello.
    cd src/main/java/hello
  4. Atualize Application.java com o seguinte código:
    package hello;
                            
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @SpringBootApplication
    @RestController
    public class Application {
    	
    	@RequestMapping("/")
    	public String home() {
    		return "<h1>Spring Boot Hello World!</h1>";
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(Application.class, args);
    	}
    
    }
  5. Salve o arquivo.
Executar o Aplicativo Local
  1. Passe para o diretório gs-spring-boot-docker/initial.
  2. Empacote o aplicativo:
    mvn package
    Exemplo de saída:
    [INFO] Replacing main artifact with repackaged archive
    [INFO] BUILD SUCCESS
  3. Execute o aplicativo em segundo plano:
    java -jar target/spring-boot-docker-0.0.1-SNAPSHOT.jar &

    Exemplo de saída:

      
      .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
      \/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
    :: Spring Boot ::                (vx.x.x)
    
    hello.Application: Started Application in x seconds (JVM running for x.x)
  4. Mantenha o código em execução e teste o aplicativo de uma das seguintes maneiras:
    • No terminal do Cloud Shell, informe o seguinte código:
      curl -X GET http://localhost:8080

      Saída:

      <h1>Spring Boot Hello World!</h1>
  5. Interrompa o aplicativo em execução.
    • Quando terminar de testar, obtenha o ID do processo do seu aplicativo e interrompa o processo.
      ps -ef
    • Interrompa o processo.
      kill <your-pid->
Criar uma Imagem Docker
Uma imagem do Docker contém um aplicativo, suas dependências e instruções para executar o aplicativo.
  1. Passe para o diretório gs-spring-boot-docker/initial.
  2. Crie um arquivo chamado Dockerfile.
    FROM openjdk:8-jdk
    RUN addgroup --system spring && adduser --system spring -ingroup spring
    USER spring:spring
    ARG JAR_FILE=target/*.jar
    COPY ${JAR_FILE} app.jar
    ENTRYPOINT ["java","-jar","/app.jar"]

    Se funcionar, remova o sudo nos comandos do docker a seguir.

  3. Crie a imagem Docker:
    docker build -t spring-boot-hello .

    Exemplo de saída:

    Successfully built xxxxxxxxxxxx
    Successfully tagged spring-boot-hello:latest                    
  4. Execute a imagem do Docker:
    docker run -p 8080:8080 -t spring-boot-hello &

    Você obterá o mesmo resultado da execução local do aplicativo.

  5. Interrompa o aplicativo em execução.
Parabéns! Você criou com sucesso uma imagem do Spring Boot Docker.

Referência: tutorial do Spring Boot Docker

4. Implantar Sua Imagem do Docker

Envie sua imagem do Spring Boot Docker ao OCI Container Registry com o comando push. Em seguida, use a imagem para implantar seu aplicativo.

Criar um Repositório do Docker
  1. Abra o menu de navegação e clique em Serviços ao Desenvolvedor. Em Contêineres e Artefatos, clique em Registro de Contêiner.
  2. Na navegação esquerda, selecione <your-compartment-name>.
  3. Clique em Criar Repositório.
  4. Crie um repositório privado com sua opção de nome de repositório:
    <repo-name> = <image-path-name>/<image-name>

    Exemplo: spring-projects/spring-boot-hello-app

    Agora você está pronto para enviar sua imagem local ao registro do OCI.
    Observação

    Antes de enviar uma imagem para um compartimento, você deverá criar um repositório nesse compartimento.
    Observação

    A barra em um nome de repositório não representa uma estrutura de diretório hierárquica. O <image-path-name> opcional ajuda a organizar seus repositórios.
Enviar Sua Imagem Local

Com sua imagem local do Docker criada, envie a imagem para o Container Registry.

Siga estas etapas.

  1. Abra uma janela de terminal.
  2. Faça log-in no OCI Container Registry:
    docker login <region-key>.ocir.io

    Você é solicitado a informar seu nome de log-in e sua senha.

    • Nome de usuário: <tenancy-namespace>/<user-name>
    • Senha: <auth-token>
  3. Liste suas imagens locais do Docker:
    docker images

    As imagens do Docker no sistema são exibidas. Identifique a imagem criada na última seção: spring-boot-hello

  4. Marque sua imagem local com o URL do registro mais o nome do repositório, para que você possa enviá-la para esse repositório.
    docker tag <your-local-image> <repo-url>/<repo-name>
    • Substitua <repo-url>/<repo-name> por:
      <region-key>.ocir.io/<tenancy-namespace>/<repo-name>
    • Substitua <repo-name> por:

      <image-folder-name>/<image-name> na seção Criar um Repositório do Docker.

    • Exemplo:
      docker tag spring-boot-hello iad.ocir.io/my-namespace/spring-projects/spring-boot-hello-app

      Neste exemplo, os componentes são:

      • URL do Repositório: iad.ocir.io/my-namespace/
      • Nome do repositório: spring-projects/spring-boot-hello-app
    Observação

    O OCI Container Registry agora suporta a criação de um repositório de registro em qualquer compartimento, em vez de apenas no compartimento raiz (tenancy). Para enviar a imagem ao repositório criado, combine o URL do registro com o nome do repositório exato. O OCI Container Registry faz a correspondência com base no nome do repositório exclusivo e envia por push sua imagem.
  5. Verifique suas imagens do Docker para ver se a imagem foi copiada.
    docker images
    • A imagem marcada com tag ou copiada tem o mesmo ID de imagem que sua imagem local.
    • O nome da imagem copiada é:
      <region-key>.ocir.io/<tenancy-namespace>/<image-folder-name>/<image-name>
  6. Envie a imagem ao Container Registry.
    docker push <copied-image-name>:latest
    Exemplo:
    docker push iad.ocir.io/my-namespace/spring-projects/spring-boot-hello-app:latest
  7. Abra o menu de navegação e clique em Serviços ao Desenvolvedor. Em Contêineres e Artefatos, clique em Registro de Contêiner.

Localize sua imagem no Container Registry após a conclusão do comando push.

Implantar a Imagem
Com sua imagem no Container Registry, agora você pode implantar sua imagem e aplicativo.
  1. Crie um segredo de registro para seu aplicativo. Esse segredo autentica sua imagem quando você o implanta no seu cluster.

    Para criar seu segredo, preencha as informações neste modelo .

    kubectl create secret docker-registry ocirsecret --docker-server=<region-key>.ocir.io  --docker-username='<tenancy-namespace>/<user-name>' --docker-password='<auth-token>'  --docker-email='<email-address>'

    Após a execução do comando, você obtém uma mensagem semelhante a: secret/ocirsecret created.

  2. Verifique se o segredo foi criado. Emita o seguinte comando:
    kubectl get secret ocirsecret --output=yaml

    A saída inclui informações sobre seu segredo no formato yaml.

  3. Determine o URL do host para sua imagem de registro usando o seguinte modelo:
    <region-code>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>
    Exemplo:
    iad.ocir.io/my-namespace/spring-projects/spring-boot-hello-app:latest
  4. Em seu sistema, crie um arquivo chamado sb-app.yaml com o seguinte texto:
    Substitua os seguintes placeholders:
    • <your-image-url>
    • <your-secret-name>
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: sbapp
    spec:
      selector:
        matchLabels:
          app: sbapp
      replicas: 3
      template:
        metadata:
          labels:
            app: sbapp
        spec:
          containers:
          - name: sbapp
            image: <your-image-url>
            imagePullPolicy: Always
            ports:
            - name: sbapp
              containerPort: 8080
              protocol: TCP
          imagePullSecrets:
            - name: <your-secret-name>
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: sbapp-lb
      labels:
        app: sbapp
      annotations:
        service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
        service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
        service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
    spec:
      type: LoadBalancer
      ports:
      - port: 8080
      selector:
        app: sbapp
  5. Implante seu aplicativo com o comando a seguir.
    kubectl create -f sb-app.yaml
    Saída:
    deployment.apps/sbapp created
    Observação

    No arquivo sb-app.yaml, o código após os traços adiciona um balanceador de carga flexível.
Testar Seu Aplicativo
Depois de implantar seu aplicativo, o balanceador de carga poderá demorar alguns segundos para ser carregado.
  1. Verifique se o balanceador de carga está ativo:
    kubectl get service

    Repita o comando até que o balanceador de carga tenha um endereço IP designado.

    Observação

    Ao aguardar a implantação do balanceador de carga, você pode verificar o status do cluster com estes comandos:
    • Obter cada status de pods: kubectl get pods
    • Obter status do aplicativo: kubectl get deployment
  2. Use o endereço IP do balanceador de carga para estabelecer conexão com seu aplicativo em um browser:
    http://<load-balancer-IP-address>:8080

    O browser exibe: Spring Boot Hello World!

  3. Cancele a implantação do seu aplicativo no cluster. (Opcional) Para remover seu aplicativo, execute este comando:
    kubectl delete -f sb-app.yaml
    Saída:
    deployment.apps/sbapp deleted
    service "sbapp-lb" deleted

    Seu aplicativo agora foi removido do seu cluster.

O Que Vem a Seguir

Você criou com sucesso um aplicativo Hello World, implantou-o em um cluster do Kubernetes e o tornou acessível na internet, usando Spring Boot e OCI Cloud Shell.

Para explorar mais informações sobre desenvolvimento com produtos Oracle, confira estes sites: