Documentação do Oracle Cloud Infrastructure

Kubernetes: 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:

  • Configurar um cluster do Kubernetes no OCI.
  • Configure a CLI do OCI para acessar seu cluster.
  • Crie um aplicativo Spring Boot e uma imagem do Docker.
  • Envie a imagem ao OCI Container Registry.
  • Implante o aplicativo Docker no seu cluster.
  • 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
  • Para Container Registry, Kubernetes e Balanceadores de Carga:
  • Para criar aplicativos e imagens do Docker:
    • Um dos seguintes ambientes locais:
    • Os seguintes aplicativos em seu ambiente local:
      • JDK 11 e defina JAVA_HOME em .bashrc.
      • Instalador de Python 3.6.8+ e pip para Python 3
      • Cliente Kubernetes 1.11.9+
      • Apache Maven 3.0+
      • Docker 19.0.3+
      • Git 1.8+
Observação

Se você não quiser configurar os aplicativos necessários no seu ambiente local, poderá usar em seu lugar o Cloud Shell do Oracle Cloud Infrastructure. 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. Siga as etapas em:

Kubernetes Usando o Cloud Shell: Implantar um Aplicativo Spring Boot

Obter os Aplicativos

Se você quiser usar uma instância de computação do OCI Free Tier Linux para gerenciar sua implantação, as seções a seguir fornecem informações para instalar o software necessário.

Instalar uma Instância do Linux
  • Instale uma VM Linux com uma forma de computação Always Free no Oracle Cloud Infrastructure. Você precisará de uma máquina com suporte a ssh para se conectar à sua instância do Linux.
    • Instalar uma VM do Oracle Linux
      • Siga as seções 2 e 3.
      • Se você tiver uma conta paga, na seção 2, escolha suas opções de computação com base nas suas ofertas.
      • Para estabelecer conexão com sua instância, na seção 4, siga as etapas de 1 a 5.
      • Ignore as instruções do Apache.
    • Instalar uma VM com Ubuntu
      • Siga as seções 2 e 3.
      • Se você tiver uma conta paga, na seção 2, escolha as opções de computação com base nas suas ofertas.
      • Para estabelecer conexão com sua instância, na seção 4, siga as etapas de 1 a 5.
      • Ignore as instruções do Apache.
      • Para atualizar as definições de firewall, na seção 4, execute a etapa 8.
Instalar o JDK
  1. Verifique sua instalação atual: 
    java -version
  2. Para instalar o JDK 11, execute os seguintes comandos:
    • Oracle Linux: 
      sudo yum update
      yum list jdk*
      sudo yum install -y <jdk-version-of-your-choice>
    • Ubuntu:
      sudo apt update
      sudo apt install -y openjdk-11-jdk-headless
  3. Verifique a instalação. 
    java -version
  4. Defina JAVA_HOME em .bashrc.

    Atualize o arquivo:

    vi .bashrc

    No arquivo, anexe o seguinte texto e salve o arquivo:

    # set JAVA_HOME
export JAVA_HOME=<path-to-jdk>

    Exemplos:

    # set JAVA_HOME in Oracle Linux
export JAVA_HOME=/usr/java/jdk-11.0.10 
    # set JAVA_HOME in Ubuntu
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  5. Ative o comando anterior na janela atual. 
    source ~/.bashrc
Instalar Python 3 e Pip 3
  1. Verifique sua instalação atual.
    python3 --version
  2. Para Python 3, execute os seguintes comandos:
    • Oracle Linux: 
      sudo yum update
      sudo yum install -y python3
    • Ubuntu:
      sudo apt update
      sudo apt install -y python3
  3. Verifique a instalação do pip para o Python3.
    pip3 -V

    Exemplo de saída se o pip para Python3 estiver instalado:

    pip <version> from xxx/lib/python3.x/site-packages/pip (python 3.x)
  4. Para instalar o pip para Python 3, execute os seguintes comandos:
    • Oracle Linux: 
      sudo yum update
      sudo yum install -y python3-pip
    • Ubuntu:
      sudo apt update
      sudo apt install -y python3-pip
  5. Verifique a instalação do pip para Python 3.
    pip3 -V
Instalar o Cliente Kubernetes
  1. Verifique sua instalação atual: 
    kubectl version --client
    Se você tiver o Kubernetes, a versão será <major-version>.<minor-version>. Por exemplo, para a versão 1.20, você obtém o seguinte:
    version.Info{Major:"1", Minor:"20"...
  2. Para instalar o cliente kubectl, consulte os seguintes links:
  3. Verifique a instalação. 
    kubectl version --client
Instalar Apache Maven
  1. Verifique sua instalação atual.
    mvn --version
  2. Para instalar o Apache Maven, consulte os seguintes links:
  3. Verifique a instalação. 
    mvn --version
Instalar o Docker
  1. Verifique sua instalação atual: 
    docker -v
  2. Oracle Linux

    Para instalar o Docker no Oracle Linux, execute os comandos a seguir.

    sudo yum install docker-engine
    sudo systemctl start docker
    sudo systemctl enable docker

    Observação: O último comando permite que o Docker seja iniciado nas reinicializações.

  3. Ubuntu Linux

    Para instalar o Docker no Ubuntu Linux, consulte o seguinte link: Obter Docker

  4. Verifique a instalação. 
    docker -v

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)
    • Localize o armazenamento de volume em blocos 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)
    • Localize o número de balanceadores de carga flexíveis disponíveis:
      • Nome do Limite: lb-flexible-count
      • Disponível: no mínimo 1
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 Tenancy: <your_tenancy_name>.
      • 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>
Configurar a Interface de Linha de Comando do OCI
Instalar um Ambiente Virtual e um Wrapper Python

O Python virtualenv cria uma pasta que contém todos os arquivos executáveis e bibliotecas do seu projeto.

O virtualenvwrapper é uma extensão para virtualenv. Ele fornece um conjunto de comandos que tornam o trabalho com ambientes virtuais muito mais agradável. Ele também coloca todos os seus ambientes virtuais em um só lugar. O virtualenvwrapper fornece preenchimento de guia em nomes de ambiente.

  1. Instale virtualenv.
    pip3 install --user virtualenv
  2. Instale virtualenvwrapper.
    pip3 install --user virtualenvwrapper
  3. Localize o local do script virtualenvwrapper.sh.
    grep -R virtualenvwrapper.sh
    Exemplo de caminhos:
    • Exemplo do Linux: /home/ubuntu/.local/bin/virtualenvwrapper.sh
    • Exemplo de MacOS: /usr/local/bin/virtualenvwrapper.sh
  4. Configure o encapsulador do ambiente virtual em .bashrc.
    sudo vi .bashrc

    Anexe o texto a seguir.

    # set up Python env
export WORKON_HOME=~/envs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
source <path-to-virtualenvwrapper.sh>

    Substitua <path-to-virtualenvwrapper.sh> por seu valor.

    Com base na localização de arquivos binários Python3 em seu ambiente, atualize /usr/bin/python3 para sua localização correta.

    Salve o arquivo.

  5. Ative os comandos na janela atual.
    source ~/.bashrc
    Exemplo de saída:
    virtualenvwrapper.user_scripts creating /home/ubuntu/envs/premkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postmkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/initialize
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/premkvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postmkvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/prermvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postrmvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/predeactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postdeactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postactivate
Instalar a CLI do OCI
  1. Inicie um ambiente virtual.
    workon cli-app
  2. Confirme se o nome do seu ambiente virtual, cli-app, aparece à esquerda do prompt de comando.

    Exemplo: (cli-app) ubuntu@<ubuntu-instance-name>:~$

  3. Instale a CLI do OCI.
    pip3 install oci-cli
  4. Teste a instalação:
    oci --version

    Se tudo estiver configurado corretamente, você obterá a versão.

    oci --help
Configurar a CLI do OCI
  1. Digite o seguinte comando no ambiente virtual:
    oci setup config
  2. Informe suas respostas na seção Reunir Informações Necessárias:
    • Localização da sua configuração [$HOME/.oci/config]: <take-default>
    • OCID DO Usuário: <user-ocid>
    • OCID da Tenancy: <tenancy-ocid>
    • Região (por exemplo, us-ashburn-1): <region-identifier>
  3. Digite as informações a seguir para configurar suas chaves de criptografia da API OpenSSL:
    • Gerar um novo par de chaves RSA de Assinatura de API? [S/n]: S
    • Diretório das suas chaves [$HOME/.oci]: <take-default>
    • Nome da sua chave [oci_api_key] <take-default>
  4. Desative o ambiente virtual: 
    deactivate

    O prefixo (cli-app) em seu ambiente não é mais exibido.

Observação

Sua chave privada é oci_api_key.pem e sua chave pública é oci_api_key_public.pem.
Adicione a Chave Pública à Conta de Usuário.
  1. Ative o ambiente cli-app:
    workon cli-app
  2. Exiba a chave pública.
    cat $HOME/.oci/oci_api_key_public.pem
  3. Copie a chave pública.
  4. Adicione a chave pública à sua conta de usuário:
    • Vá até a Console.
    • 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.
    • Clique em Chaves de API.
    • Clique em Adicionar Chave de API.
    • Clique em Colar Chave Pública.
    • Cole o valor da etapa anterior, incluindo as linhas com BEGIN PUBLIC KEY e END PUBLIC KEY.
    • Clique em Adicionar.
Observação

  • Sempre que você quiser usar a CLI do OCI, ative-a com: workon cli-app
  • Quando você altera nomes de projeto, workon desativa seu ambiente de trabalho atual. Dessa forma, é possível alternar rapidamente entre ambientes.

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. Selecione seu compartimento na lista drop-down Compartimento.
  6. Clique em Criar Política.
  7. 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)
  8. Para o Criador de Política, clique em Mostrar editor manual.
  9. Cole na seguinte política:
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  10. Clique em Criar.

Referência: O resource-type compartments em Combinações Verbos + Resource-Type para o Serviço IAM

Criar um Compartimento

Crie um compartimento para os recursos criados neste tutorial.

  1. Acesse a 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 Principal: <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, essencialmente 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 drop-down 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
  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 Acesso Local ao seu Cluster

Depois de criar um cluster do Kubernetes, configure o sistema local 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 Local.
  6. Siga as etapas fornecidas na caixa de diálogo. Eles são reimpressos aqui para sua referência.
    Observação

    Se você não estiver em seu ambiente virtual, digite: workon cli-app antes de executar comandos kubectl.

    Verifique sua versão da CLI oci.

    oci -v

    Torne .kube o seu diretório, se ele não existir.

    mkdir -p $HOME/.kube

    Crie um 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>

    Exporte a variável de ambiente KUBECONFIG.

    export KUBECONFIG=$HOME/.kube/config
    Observação

    Se você quiser que a variável de ambiente inicie em um novo shell, adicione export KUBECONFIG=$HOME/.kube/config ao arquivo ~/.bashrc.
  7. Teste a configuração do cluster com os comandos a seguir.

    Listar clusters:

    kubectl get service

    Obtenha detalhes da implantação:

    kubectl describe deployment

    Obtenha pods:

    kubectl get pods
    Observação

    Como nenhum aplicativo é implantado, os dois últimos comandos produzem: "Nenhum recurso encontrado no namespace padrão."
    Observação

    Para verificar outro cluster, especifique outro arquivo de configuração na linha de comando. Exemplo:
    kubectl --kubeconfig=</path/to/config/file>

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

3. Criar um Aplicativo Local

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

Criar um Aplicativo Local
  1. Faça uma cópia do 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: 
    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:
    • Em um novo terminal conectado à sua instância, digite o seguinte código:
      curl -X GET http://localhost:8080

      Saída:

      <h1>Spring Boot Hello World!</h1>
    • Carregue o seguinte endereço em um browser:
      localhost:8080

      Você só poderá usar a segunda opção se o seu ambiente for local.

  5. Interrompa o aplicativo em execução. Exemplo: Ctrl + C
Criar uma Imagem Docker
Uma imagem do Docker contém um aplicativo, suas dependências e instruções para executar o aplicativo.
Observação

Para MacOS, você pode remover o sudo nos comandos docker.
  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"]
  3. Crie a imagem Docker: 
    sudo 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: 
    sudo 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ências:

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> = <repo-prefix>/<image-name>

    Exemplo: spring-projects/spring-boot-hello

    Agora você está pronto para enviar sua imagem local ao Container Registry.
    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 <repo-prefix> opcional ajuda a organizar seus repositórios.
Enviar Sua Imagem Local
Observação

Para MacOS, você pode remover o sudo nos comandos docker.
  1. Abra uma janela de terminal.
  2. Faça log-in no OCI Container Registry: 
    sudo 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: 
    sudo 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. 
    sudo 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:

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

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

      Neste exemplo, os componentes são:

      • <repo-url>: iad.ocir.io/my-namespace/
      • <repo-name>: spring-projects/spring-boot-hello
    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 está marcada com tag. 
    sudo docker images
    • A imagem marcada aponta para sua imagem local e tem o mesmo ID de imagem da sua imagem local.
    • O nome de imagem marcado com tag é:
      <region-key>.ocir.io/<tenancy-namespace>/<repo-prefix>/<image-name>
  6. Envie a imagem ao Container Registry. 
    sudo docker push <tagged-image-name>:latest
    Exemplo:
    sudo docker push iad.ocir.io/my-namespace/spring-projects/spring-boot-hello: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.
  8. Localize sua imagem no Container Registry após a conclusão do comando push.
Observação

Você só pode enviar imagens que incluam o URL do registro em seu nome.
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-prefix>/<image-name>:<tag>
    Exemplo:
    iad.ocir.io/my-namespace/spring-projects/spring-boot-hello: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.
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 público designado.

  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. (Opcional) Para cancelar a implantação do seu aplicativo no cluster, execute o seguinte 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

Parabéns! Você criou com sucesso um aplicativo Hello World, implantou-o em um cluster do Kubernetes e o tornou acessível na internet, usando a estrutura do Spring Boot.

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