Crie Imagens de Contêiner Multiplataforma Usando o Podman no Oracle Linux

Introdução

Esta demonstração mostra a criação de uma imagem de contêiner multiplataforma usando o Podman no Oracle Linux.

Objetivos

Neste tutorial, você aprenderá a:

Configurar o Podman para conectividade remota
Estabelecer conexão com uma instância remota do Podman
Crie imagens específicas da plataforma a partir de um único Containerfile
Enviar imagens específicas da plataforma para o Oracle Cloud Infrastructure Registry (OCIR)
Criar uma lista de manifestos que inclua imagens de plataforma específica
Enviar a lista de manifestos para o OCIR
Inspecionar a lista de manifestos hospedados pelo OCIR para ver as plataformas disponíveis
Puxe e execute a imagem

Pré-requisitos

Acesso a uma tenancy da Oracle Cloud Infrastructure (OCI)
Uma instância do Oracle Linux x86_64
Uma instância do Oracle Cloud Developer aarch_64
Acesso ao Oracle Cloud Infrastructure Registry

Implantar um Servidor Podman

Crie uma instância de computação do Oracle Linux.

Você pode usar a imagem e a forma padrão, desde que a forma use uma arquitetura x86_64. Selecione ou crie uma sub-rede pública e designe um endereço IPv4.

Esta etapa oferece suporte ao uso das formas Micro disponíveis na camada Always Free Tier.
Quando a instância estiver em execução, faça log-in na instância.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Onde:
- <SSH_KEY> é a parte privada da sua chave SSH usada ao provisionar a instância de computação. Exemplo: ~/.ssh/id_rsa
- <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> é o endereço IP público da instância da computação.

Instalar e Configurar o Podman para Acesso Remoto

Você pode executar esses comandos como a conta de usuário opc padrão na instância de computação ou qualquer usuário com acesso sudo.

Atualize o sistema com as últimas correções de segurança e erratas.
```
sudo dnf -y update
```
Instale os pacotes ou módulos do Podman.

Oracle Linux 8:
```
sudo dnf module install -y container-tools:ol8
```
Oracle Linux 9 e Oracle Linux 10:
```
sudo dnf install -y container-tools
```
O módulo ou pacote de ferramentas de contêiner instala o podman e outras ferramentas de contêiner, incluindo skopeo e buildah. Um pacote essencial é o container-selinux, que permite executar podman como usuário não raiz em um sistema ativado para SELinux, que o Oracle Linux ativa por padrão.
Ative o soquete Podman.

systemd ouvirá esse soquete e ativará uma instância do Podman sempre que um cliente remoto ativá-lo. Quando a conexão for fechada, o systemd fará shutdown da instância do Podman.

Observação: É possível configurar o acesso remoto do Podman no modo sem raiz, mas isso está além do escopo deste tutorial.
```
sudo systemctl enable --now podman.socket
```
Verifique o caminho do soquete.
```
sudo systemctl status podman.socket
```
A saída mostra o listening do soquete e sua localização está em /run/podman/podman.sock.

É isso aí, mas fique conectado à instância do servidor Podman para executar a configuração SSH sem senha mais adiante neste tutorial.

Implante uma Instância de Desenvolvedor do Oracle Cloud

O Oracle Ampere A1 Compute é uma plataforma de alto desempenho que combina os processadores Oracle Cloud Infrastructure (OCI) e Ampere Altra Arm. Ele fornece um desempenho determinístico, segurança comprovada e um amplo ecossistema de desenvolvedores que inclui ferramentas e ambientes populares (OS, Kubernetes - OKE, SDKs e CLIs).

A OCI lista a imagem do Oracle Cloud Developer Image as a Platform com todas as ferramentas de desenvolvedor populares instaladas, incluindo Git, Node.js, Java e GraalVM.

Crie uma instância de computação do Oracle Cloud Developer.

Selecione a imagem do Oracle Cloud Developer e uma forma Ampere. Selecione a mesma sub-rede pública que a instância do servidor Podman e designe um endereço IPv4.
Decida usar Regras de Entrada ou encaminhamento de porta SSH.

Você pode acessar o aplicativo web de demonstração que criaremos de duas maneiras. Enquanto você pode ativar ambos, você só precisa escolher um ou outro.

(Opcional) Criar uma Regra de Entrada

O uso de uma Regra de Entrada é um processo de duas etapas. Essa opção abre o acesso à sub-rede pela internet e continua a conceder acesso à instância na porta especificada mesmo após uma reinicialização. Primeiro, crie a regra no OCI e, em seguida, abra a porta no firewalld na instância do Oracle Linux.

Adicione uma Regra de Entrada à sua sub-rede pública.

A regra deve permitir o tráfego de entrada na porta 5808/tcp do 0.0.0.0/0. A regra entra em vigor imediatamente após a criação.
Abra um novo terminal e conecte-se à instância do Oracle Cloud Developer via SSH.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Adicione acesso ao aplicativo web de demonstração.

sudo firewall-cmd --permanent --add-port=5808/tcp
sudo firewall-cmd --reload

Confirme as alterações no firewall.
```
sudo firewall-cmd --list-all
```
A saída mostra ports: 5808/tcp disponível.

Usar Encaminhamento de Porta SSH

Abra um terminal e conecte-se via SSH à instância do Oracle Cloud Developer.

A opção -L ativa o encaminhamento local, que abre uma porta local para estabelecer conexão por meio de um túnel SSH com o aplicativo web de demonstração remota.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Criar uma Imagem de Contêiner para um Aplicativo Web e Executá-la Localmente

Clone o repositório Git do aplicativo de demonstração.

Para este tutorial, você implantará o RasDash, um aplicativo web de monitoramento de servidor baseado em Node.js.
```
git clone https://github.com/sykeben/RasDash.git
```
Altere para o diretório do código-fonte.
```
cd  ~/RasDash
```

Crie um Containerfile para criar e servir o aplicativo Web.

cat << EOF > Containerfile
FROM ghcr.io/oracle/oraclelinux8-nodejs:14
COPY . /app
WORKDIR /app
RUN npm install && \
  npm test
CMD ["/usr/bin/node", "app.js", "service"]
EOF

Crie e execute a imagem na instância local.

Crie a imagem do contêiner localmente usando podman e marque a imagem com a versão do aplicativo e a arquitetura da plataforma. Essas informações serão úteis posteriormente quando você enviar cada imagem de plataforma para o Oracle Cloud Infrastructure Registry (OCIR) e quando criar um manifesto das duas imagens de plataforma.
```
sudo podman build --format docker --tag rasdash:0.3.4-arm64 .
```
A linha final será exclusiva para a criação do aplicativo.
Execute um contêiner usando a imagem.
```
sudo podman run --rm --init -detach --name rasdash --publish 5808:5808 localhost/rasdash:0.3.4-arm64
```
A compilação que o Podman retorna é exclusiva de cada instância de contêiner.
Exiba o contêiner em execução.
```
sudo podman ps
```
A saída exibe o contêiner como Up e em execução.
Exiba os logs do contêiner.
```
sudo podman logs rasdash
```
A saída mostra o [STATE] Server started.
Exiba o aplicativo Web.

Abra um navegador na sua máquina local e navegue até http://localhost:5808. Se você tiver criado as regras de entrada e firewall, poderá usar o endereço IP público da instância do Oracle Cloud Developer em vez de localhost.

Observação: A métrica de temperatura da CPU exibirá -1, pois as instâncias virtuais no OCI não podem acessar dados físicos de hardware.
Interrompa o contêiner existente.
```
sudo podman stop rasdash
```

Configurar SSH sem Senha entre as Instâncias

O Podman se comunica usando SSH entre instâncias para fins de segurança. Para uma experiência mais perfeita, crie um par de chaves pública/privada em sua instância do Cloud Developer e copie-o para o servidor Podman Remote para que você possa usar SSH da instância do desenvolvedor sem ser solicitado a fornecer uma senha.

Gere um par de chaves pública/privada na instância do Oracle Cloud Developer.
```
ssh-keygen -b 4096 -f ~/.ssh/id_rsa -q -N ""
```
Copie o conteúdo do arquivo da chave pública.
```
cat ~/.ssh/id_rsa.pub
```
Selecione a saída do comando cat e copie-a.
Alternar para a instância do servidor Podman.
Abra o arquivo em vi.
```
vi ~/.ssh/authorized_keys
```
Cole o conteúdo da chave pública no arquivo de chaves autorizadas.

Salve e feche o arquivo.
Certifique-se de aplicar as permissões corretas do sistema de arquivos ao diretório e aos arquivos SSH.
```
chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys
```
Alterne para a instância do Cloud Developer.
Teste se você pode usar SSH no servidor Podman como o usuário opc sem exigir uma senha.
Observação: Se você tiver algum problema, consulte a seguinte documentação:
```
ssh opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Depois de verificar se você pode se conectar sem exigir uma senha, certifique-se de exit a sessão SSH entre a instância do Oracle Cloud Developer e o servidor do Podman.
Alternar para a instância do servidor Podman.

Substitua o arquivo de chaves autorizadas do usuário raiz.

cat /home/opc/.ssh/authorized_keys | sudo tee /root/.ssh/authorized_keys

Alterne para a instância do Cloud Developer.
Teste se você pode usar SSH com o usuário opc na instância do Cloud Developer para o usuário root no servidor do Podman.
```
ssh root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Você pode exit a sessão após testar com sucesso a conexão SSH com o servidor Podman como o usuário raiz.

Criar uma Conexão de Sistema com o Servidor Podman

Crie uma conexão do sistema Podman entre a instância do Oracle Cloud Developer e o serviço Podman em execução no servidor Podman.
```
sudo podman system connection add --identity ~/.ssh/id_rsa amd64 ssh://root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>/run/podman/podman.sock
```
No comando acima, certifique-se de substituir <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> pelo endereço IP ou nome do host do seu servidor Podman.
Verifique se você adicionou a conexão com sucesso.
```
sudo podman system connection list
```
A saída exibe a conexão amd64 com o valor Default definido como true. O Podman usa essa conexão se o sistema tiver várias conexões configuradas.

Criar uma Imagem no Servidor Podman Remoto

Agora você deverá poder usar o podman --remote para enviar comandos da instância do Oracle Cloud Developer para a instância remota do servidor Podman.

Teste obtendo os detalhes do servidor Podman.
```
sudo podman --remote info
```
A arquitetura deve ser reportada como arm64.
Crie a imagem remota.

O Podman copiará todo o contexto para a instância remota automaticamente.
```
cd ~/RasDash
sudo podman --remote build --format docker --tag rasdash:0.3.4-amd64 .
```
Verifique se a imagem existe no servidor Podman remoto.

OBSERVAÇÃO: o Podman não copia a imagem que cria de volta para a máquina cliente, portanto, a imagem não será listada se você executar sudo podman images. No entanto, está disponível na máquina remota.
```
sudo podman --remote images
```
Exemplo de Saída:
```
REPOSITORY                          TAG          IMAGE ID      CREATED        SIZE
localhost/rasdash                   0.3.4-amd64  3a1b9755ebdd  8 seconds ago  439 MB
...
```
Verifique a arquitetura da imagem local.

O método final de validar que cada imagem foi construída para (e sobre) uma plataforma e arquitetura específicas usa jq para extrair o valor do campo Architecture no manifesto de cada imagem.
```
sudo podman inspect rasdash:0.3.4-arm64 | jq -r '.[] | .Architecture'
```
A imagem local reporta sua arquitetura como arm64.

Verifique a imagem remota.

sudo podman --remote inspect rasdash:0.3.4-amd64 | jq -r '.[] | .Architecture'

A imagem remota é reportada como amd64.

Criar um Repositório do Container Registry

Na Console do Oracle Cloud Infrastructure, navegue até a seção Container Registry e crie um repositório para armazenar seu aplicativo de várias plataformas.

Para obter mais detalhes, consulte Criando um Repositório na Documentação do Oracle Cloud Infrastructure.

Crie o repositório demo/rasdash privado.
Verifique os detalhes do novo repositório.

Reunir as Credenciais do Repositório do Container Registry

A tabela a seguir fornece exemplos de valores usados nas etapas subsequentes neste tutorial. O exemplo iad é a chave da região para a região Leste dos EUA (Ashburn). Se sua região for Central da Alemanha (Frankfurt), a chave da região será fra. Consulte a documentação Regiões e Domínios de Disponibilidade para obter uma tabela completa que lista as chaves de região disponíveis.

Dados do Registro	Marcador do Tutorial	Notas
REGISTRY_NAMESPACE	`gse00015915`	Exibido no painel de informações do repositório como "Namespace"
REPOSITORY_NAME	`demo/rasdash`	Exibido sob o nome do compartimento
OCIR_INSTANCE	`iad.ocir.io`	Usar `<region>.ocir.io`

Consulte Como Enviar Imagens Usando a CLI do Docker, se necessário. Este procedimento descreve o processo de login necessário para enviar imagens ao Container Registry usando a CLI.

Obtenha seu nome de usuário.

Você precisa de um nome de usuário e um token de autenticação para fazer log-in no registro do contêiner. Para obter o nome de usuário, no canto superior direito da console do Oracle Cloud Infrastructure, abra o menu Perfil (ícone de menu Usuário) e clique em Meu perfil para exibir os detalhes.

Copie e salve o nome de usuário, incluindo o tenancy-namespace exibido no console.
Gerar um Token de Autenticação.

Role a página Meu perfil na console e selecione Tokens de Autenticação em Recursos.

Selecione o botão Gerar Token e forneça uma descrição do demo para o novo token.

Após gerar o token, certifique-se de copiá-lo e salvá-lo.

A tabela a seguir fornece exemplos de valores usados nas etapas subsequentes neste tutorial.

Nome do usuário	Marcador do Tutorial
REGISTRY_NAMESPACE	`gse00015915`
USERNAME	`luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e`
TOKEN	`]y#W_iS9GKC}4l1Gq9Fn`
OCIR_INSTANCE	`iad.ocir.io`

Crie variáveis de ambiente para uso no comando podman login.

Crie as variáveis de ambiente USER e TOKEN usando seu nome de usuário e token. Certifique-se de incluir o <REGISTRY_NAMESPACE> como parte do nome de usuário.

export OCIR_INSTANCE="iad.ocir.io"
export OCIR_NAMESPACE="gse00015915"
export OCI_USERNAME="luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e"
export OCIR_USERNAME="$OCIR_NAMESPACE/$OCI_USERNAME"
export OCI_USER_TOKEN="]y#W_iS9GKC}4l1Gq9Fn"

Faça log-in no registro do contêiner.
```
sudo -E podman login -u $OCIR_USERNAME -p $OCIR_USER_TOKEN $OCIR_INSTANCE
```
A instância remota herdará automaticamente as credenciais de autenticação da instância do cliente.

Empurre as Imagens da Plataforma

Neste exemplo, os URIs do repositório final com tags específicas da plataforma são:

docker://iad.ocir.io/gse00015915/demo/rasdash:0.3.4-arm64
docker://iad.ocir.io/gse00015915/demo/rasdash:0.3.4-amd64

O Podman pode enviar imagens locais para registros remotos sem que a imagem precise ser marcada com antecedência.

Envie a imagem rasdash/0.3.4-arm64 local.

sudo -E podman push rasdash:0.3.4-arm64 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-arm64

Envie a imagem rasdash:0.3.4-amd64 remota.

sudo -E podman --remote push rasdash:0.3.4-amd64 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-amd64

Verifique a console do Container Registry.

Observação: O envio de uma imagem remota não gera uma saída local. Verifique a console do Container Registry para obter a tag rasdash:0.3.4-amd64 para verificar se você enviou a imagem com sucesso.

Você deverá ver duas imagens no console do Container Registry.

A imagem 0.3.4-amd64:

A imagem 0.3.4-arm64:

Criar e Enviar uma Lista de Manifestos para o Container Registry

Agora que você tem duas imagens de plataforma, é hora de criar uma lista de manifestos para permitir que os tempos de execução do contêiner selecionem a imagem apropriada para sua plataforma, que é uma combinação do sistema operacional e da arquitetura.

Como a maioria das imagens de contêiner são baseadas no Linux, os usuários geralmente se referem a uma imagem multiplataforma como uma imagem multi-arch. No entanto, também é possível combinar imagens que podem ser executadas no Windows, macOS e Linux em um único manifesto.

Crie e preencha o manifesto.

Crie uma lista de manifestos local na Instância do Cloud Developer com apenas a versão do aplicativo na tag.
```
sudo podman manifest create rasdash:0.3.4
```
Como antes, a saída da soma de verificação é exclusiva do manifesto criado e não corresponderá à acima.
Inspecione a lista de manifestos para revelar qual mediaType está sendo usado e suas imagens de membro.
```
sudo podman manifest inspect rasdash:0.3.4
```

Adicione as duas imagens específicas da plataforma à lista.

sudo -E podman manifest add rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-arm64

sudo -E podman manifest add rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-amd64

Inspecione a lista de manifestos.
```
sudo podman manifest inspect rasdash:0.3.4
```
A saída é mais interessante depois de adicionar as imagens.

Para obter compatibilidade máxima, você adicionou o parâmetro --format docker a cada comando de build, que instrui o Podman a criar a imagem usando a especificação do Manifesto de Imagem do Docker V2, do Esquema 2 (v2s2) em vez da Especificação do Manifesto de Imagem da Open Container Initiative, que o Podman usará por padrão.

Como os manifestos estão usando a especificação v2s2, o Podman usa a especificação v2s2 Manifest List associada, em vez da Open Container Initiative Image Index Specification.

Os tempos de execução de contêiner padrão usados pelos serviços Kubernetes gerenciados baseados em nuvem, incluindo o Oracle Engine for Kubernetes (OKE) e as distribuições Kubernetes auto-hospedadas locais, são compatíveis com ambas as especificações.
Envie a lista de manifestos para o Container Registry.

Agora que você criou a lista de manifestos, poderá enviá-la ao mesmo repositório do Container Registry que armazena as imagens específicas da plataforma.
```
sudo -E podman manifest push --all rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```
Esta ação é uma operação rápida porque você enviou as imagens específicas da plataforma anteriormente. O Container Registry apenas vincula a lista de manifestos às imagens existentes.
Crie e execute a imagem localmente.

Agora você pode executar uma instância da imagem local e remotamente usando a tag da lista de manifestos em vez da tag específica da plataforma.
```
sudo -E podman run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```

Crie e execute a imagem remotamente.

sudo -E podman --remote run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4

Testar as Imagens Usando um Navegador

Suponha que você tenha criado as regras de entrada e as regras firewalld necessárias nas instâncias. Nesse caso, você deverá poder abrir seu browser e navegar até http://<PUBLIC_IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>:5808 e http://<PUBLIC_IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>:5808 para abrir o aplicativo Web RasDash em execução em cada instância.

Caso contrário, você poderá usar o encaminhamento de porta SSH como antes criando dois túneis da sua máquina local.

Abra um túnel SSH para a instância do Oracle Cloud Developer.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```
Abra um browser na sua máquina local e navegue até http://localhost:5808 para exibir o aplicativo Web baseado em arm64 na instância do Cloud Development.
Saia da sessão de túnel SSH.
Abra um túnel SSH para a instância do servidor Podman.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Atualize o browser na sua máquina local que aponta para http://localhost:5808 para exibir o aplicativo Web baseado em amd64 na instância do Servidor Podman.

Próximas Etapas

Depois de concluir este tutorial, você deverá saber como criar imagens que podem ser implantadas em repositórios OCIR privados e públicos. Você pode usar essas imagens em vários locais, como Oracle Engine for Kubernetes (OKE) ou Oracle Cloud Native Environment. Ao implantar suas imagens em hosts fora do Oracle Cloud Infrastructure, incluindo o Podman Desktop para Mac ou Windows, você deve garantir que o repositório seja público.

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal do Oracle Learning YouTube. Além disso, acesse education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

Build Multi-Platform Container Images Using Podman on Oracle Linux

F49998-04

Oracle e/ou suas empresas afiliadas.