Documentação do Oracle Cloud Infrastructure

Kubernetes: Implantar um Aplicativo Node Express

Neste tutorial, você usa uma conta do Oracle Cloud Infrastructure para configurar um cluster do Kubernetes. Em seguida, implante um aplicativo Node Express 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 Node Express e uma Imagem do Docker.
  • Enviar sua imagem por push ao OCIR.
  • Implante seu aplicativo Node.js Docker no seu cluster.
  • Estabelecer conexão com seu aplicativo pela internet.
Um diagrama dos componentes necessários para executar um aplicativo NodeJS Express 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+
      • Node.js 10+
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 um e dois em:

Kubernetes Usando o Cloud Shell: Implantar um Aplicativo Spring Boot

Obter os Aplicativos para Linux no OCI Free Tier

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 Node.js

Instale o Node.js no seu sistema.

Executar Comandos de Instalação

Para instalar o Node.js e o NPM, execute os seguintes comandos:

  1. Oracle Linux: 
    sudo yum update

    Configure o repositório Yum para Node.js. Em seguida, instale o pacote nodejs.

    sudo yum install -y oracle-nodejs-release-el7
sudo yum install -y nodejs
  2. Ubuntu: 
    sudo apt update

    Instale os pacotes nodejs e npm.

    sudo apt install -y nodejs
sudo apt install -y npm
  3. Verifique a instalação. 
    node -v
npm -v
Configurar Firewall (Opcional)

Se você quiser fazer testes baseados em browser do seu aplicativo Node, disponibilize a porta 3000 na sua instância do Linux.

  • Oracle Linux 
    sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-service=https --permanent
sudo firewall-cmd --reload
  • Ubuntu Linux 
    sudo iptables -I INPUT 6 -m state --state NEW -p tcp --dport 3000 -j ACCEPT
sudo netfilter-persistent save
Criar uma Regra de Entrada para a sua VCN (Opcional)

Siga estas etapas para selecionar a sub-rede pública da sua VCN e adicionar a regra de entrada.

  1. Abra o menu de navegação e clique em Rede; em seguida, clique em Redes Virtuais na Nuvem.
  2. Selecione a VCN que você criou com sua instância de computação.
  3. Com sua nova VCN exibida, clique no link de sub-rede <your-subnet-name>.

    As informações da sub-rede pública são exibidas com as Listas de Segurança na parte inferior da página. Um link para a Lista de Segurança Padrão da sua VCN é exibido.

  4. Clique no link Lista de Segurança Padrão.

    As Regras de Entrada padrão da sua VCN são exibidas.

  5. Clique em Adicionar Regras de Entrada.

    Uma caixa de diálogo Adicionar Regras de Entrada é exibida.

  6. Preencha a regra de entrada com as informações a seguir.

    Preencha a regra de entrada da seguinte forma:

    • Sem monitoramento de estado: Marcado
    • Tipo de Origem: CIDR
    • CIDR de Origem: 0.0.0.0/0
    • Protocolo IP: TCP
    • Intervalo de portas de origem: (leave-blank)
    • Faixa de Portas de Destino: 3000
    • Descrição: Permitir conexões HTTP
  7. Clique em Adicionar Regra de Entrada.

    Agora são permitidas conexões HTTP. Sua VCN está configurada para o Node Express.

Você criou com sucesso uma regra de entrada que disponibiliza sua instância pela internet.

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 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 assinadas
      • 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ê a ele 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. Desativar 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.
    • Colar 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 seguintes informações:
    • 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 seguintes informações:
    • 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 seguintes informações:
    • 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 seguintes informações.
    • 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

Crie seu aplicativo Node.js.

  1. Inicie uma sessão da CLI do OCI.
  2. Crie um diretório para seu aplicativo. 
    mkdir node-hello-app
cd node-hello-app
  3. Crie um arquivo package.json.

    Crie o arquivo:

    vi package.json

    No arquivo, insira o seguinte texto, atualize os campos opcionais autor e repositório e salve o arquivo:

    {
    "name": "node-hello-app",
    "version": "1.0.0",
    "description": "Node Express Hello application",
    "author": "Example User <username@example.com>",
    "main": "app.js",
    "scripts": {
        "start": "node app.js"
    },
    "repository": {
        "type": "git",
        "url": "git://github.com/username/repository.git"
    },
    "dependencies": {
        "express": "^4.0.0"
    },
    "license": "UPL-1.0"
}
  4. Instalar os pacotes do NPM 
    npm install
  5. Crie um aplicativo "Hello, World!".

    Crie o arquivo:

    vi app.js

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

    const express = require('express')
const app = express()
port = 3000

app.get('/', function (req, res) {
    res.send('<h1>Hello World from Node.js!</h1>')
})

app.listen(port, function() {
    console.log('Hello World app listening on port ' + port);
})

Você configurou com sucesso seu aplicativo Node.js.

Executar o Aplicativo Local

Execute seu aplicativo Node.js.

  1. Execute seu aplicativo Node.js. 
    node app.js
    O servidor Node Express é iniciado e exibe o seguinte: 
    Hello World app listening on port 3000
  2. Teste o aplicativo usando curl ou seu browser.
    • Para testar com curl, digite: 
      curl -X GET http://localhost:3000
    • Para testar com seu browser, conecte uma janela do browser a: http://<your-ip-address>:3000 (Opcional).
    O aplicativo retorna 
    <h1>Hello World from Node.js!</h1>
  3. Interrompa o aplicativo em execução.

    Pressione Ctrl+C para interromper seu aplicativo na janela do terminal com a qual você começou.

Você criou com sucesso um aplicativo Hello World usando o Node.js e o Express.

Referências:

Criar uma Imagem do Docker

Em seguida, crie uma imagem do Docker para seu aplicativo Node.js Express.

  1. Certifique-se de que esteja no diretório node-hello-app.
  2. Crie uma imagem Docker. 
    docker build -t node-hello-app .

    Você receberá uma mensagem de operação bem-sucedida.

    [INFO] BUILD SUCCESS
Successfully tagged node-hello-app:latest
  3. Execute a imagem do Docker: 
    docker run --rm -p 3000:3000 node-hello-app:latest
  4. Teste o aplicativo. 
    curl -X GET http://localhost:3000
    O aplicativo retorna 
    <h1>Hello World from Node.js!</h1>
  5. Interrompa o aplicativo em execução.
Parabéns! Você criou com sucesso uma imagem do Node.js Express.

4. Implantar Sua Imagem do Docker

Envie sua imagem do Node.js Express ao OCI Container Registry. 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: node-apps/node-hello-app

    Agora você está pronto para enviar sua imagem local ao Container Registry.
    Observação

    Para que você possa enviar uma imagem do Docker para um repositório de registro, o repositório deverá existir no compartimento. Se o repositório não existir, o comando push do Docker não funcionará corretamente.
    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 sua sessão da CLI do OCI.
  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: node-hello-app

  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> por: 
      <region-key>.ocir.io/<tenancy-namespace>/
    • Substitua <repo-name> por:

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

    • Veja um exemplo depois de combinar os dois:
      docker tag node-hello-app iad.ocir.io/my-namespace/node-apps/node-hello-app

      Neste exemplo, os componentes são:

      • URL do Repositório: iad.ocir.io/my-namespace/
      • Nome do repositório: node-apps/node-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 com tag tem o mesmo ID de imagem da sua imagem local.
    • O nome de imagem marcado com tag é: 
      <region-key>.ocir.io/<tenancy-namespace>/<image-path-name>/<image-name>
  6. Envie a imagem ao Container Registry. 
    docker push <copied-image-name>:latest
    Exemplo:
    docker push iad.ocir.io/my-namespace/node-apps/node-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 comando a seguir: 
    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 modelo a seguir: 
    <region-code>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>
    Exemplo:
    iad.ocir.io/my-namespace/node-apps/node-hello-app:latest
  4. Em seu sistema, crie um arquivo chamado node-app.yaml com o seguinte texto:
    Substitua os seguintes placeholders:
    • <your-image-url>
    • <your-secret-name>
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  selector:
    matchLabels:
      app: app
  replicas: 3
  template:
    metadata:
      labels:
        app: app
    spec:
      containers:
      - name: app
        image: <your-image-url>
        imagePullPolicy: Always
        ports:
        - name: app
          containerPort: 3000
          protocol: TCP
      imagePullSecrets:
        - name: <your-secret-name>
---
apiVersion: v1
kind: Service
metadata:
  name: node-app-lb
  labels:
    app: app
  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: 3000
  selector:
    app: app
  5. Implante seu aplicativo com o seguinte comando. 
    kubectl create -f node-app.yaml
    Saída: 
    deployment.apps/node-app created
service/node-app-lb created
    Observação

    No arquivo node-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>:3000

    O browser exibe: <h1>Hello World from Node.js!</h1>

  3. Cancele a implantação do seu aplicativo no cluster. (Opcional) Para remover seu aplicativo, execute este comando: 
    kubectl delete -f node-app.yaml
    Saída:
    deployment.apps/node-app deleted
service "node-app-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 a estrutura do Node Express.

Confira estes sites para explorar mais informações sobre desenvolvimento com produtos Oracle: