Creación de imágenes de contenedor multiplataforma con Podman en Oracle Linux

Introducción

En esta demostración se muestra la creación de una imagen de contenedor multiplataforma mediante Podman en Oracle Linux.

Objetivos

En este tutorial, aprenderá a:

Configurar Podman para conectividad remota
Conexión a una instancia remota de Podman
Cree imágenes específicas de la plataforma a partir de un único archivo de contenedor
Transfiera imágenes específicas de la plataforma a Oracle Cloud Infrastructure Registry (OCIR)
Crear una lista de manifiestos que incluya ambas imágenes específicas de la plataforma
Transferir la lista de manifiestos a OCIR
Inspeccionar la lista de manifiestos alojados en OCIR para ver las plataformas disponibles
Extraer y ejecutar la imagen

Requisitos

Acceso a un arrendamiento de Oracle Cloud Infrastructure (OCI)
Una instancia x86_64 de Oracle Linux
Una instancia aarch_64 de Oracle Cloud Developer
Acceso a Oracle Cloud Infrastructure Registry

Despliegue de un servidor Podman

Cree una instancia informática de Oracle Linux.

Puede utilizar la imagen y la unidad por defecto, siempre que la unidad utilice una arquitectura x86_64. Seleccione o cree una subred pública y asigne una dirección IPv4.

Este paso soporta el uso de las unidades Micro disponibles en la capa Siempre gratis.
Una vez que la instancia se esté ejecutando, conéctese a la instancia.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Dónde:
- <SSH_KEY> es la parte privada de la clave SSH que se utiliza al aprovisionar la instancia informática. Ejemplo: ~/.ssh/id_rsa
- <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> es la dirección IP pública de la instancia informática.

Instalación y configuración de Podman para acceso remoto

Puede ejecutar estos comandos como la cuenta de usuario opc por defecto en la instancia informática o cualquier usuario con acceso sudo.

Actualice el sistema con todas las correcciones de seguridad y errores más recientes.
```
sudo dnf -y update
```
Instale los paquetes o módulos de Podman.

Oracle Linux 8:
```
sudo dnf module install -y container-tools:ol8
```
Oracle Linux 9 y Oracle Linux 10:
```
sudo dnf install -y container-tools
```
El módulo o paquete de herramientas de contenedor instala podman y otras herramientas de contenedor, incluyendo skopeo y buildah. Un paquete esencial es container-selinux, que permite ejecutar podman como usuario no raíz en un sistema activado para SELinux, que Oracle Linux activa de manera predeterminada.
Active el socket de Podman.

systemd escuchará en ese socket y activará una instancia de Podman cada vez que un cliente remoto lo active. Cuando se cierre la conexión, systemd cerrará la instancia de Podman.

Nota: Es posible configurar el acceso remoto a Podman en modo sin raíz, pero eso no se aborda en este tutorial.
```
sudo systemctl enable --now podman.socket
```
Verifique la ruta de acceso para el socket.
```
sudo systemctl status podman.socket
```
La salida muestra la recepción del socket y su ubicación está en /run/podman/podman.sock.

Eso es todo, pero manténgase conectado a la instancia del servidor Podman para realizar la configuración sin contraseña SSH más adelante en este tutorial.

Despliegue de una instancia de desarrollador de Oracle Cloud

Oracle Ampere A1 Compute es una plataforma de alto rendimiento que combina procesadores de Oracle Cloud Infrastructure (OCI) y Ampere Altra Arm. Proporciona un rendimiento determinista, seguridad probada y un amplio ecosistema de desarrolladores que incluye herramientas y entornos populares (SO, Kubernetes - OKE, SDK y CLI).

OCI muestra la imagen de desarrollador de Oracle Cloud como plataforma con todas las herramientas de desarrollador populares instaladas, incluidas Git, Node.js, Java y GraalVM.

Cree una instancia informática de Oracle Cloud Developer.

Seleccione la imagen de Oracle Cloud Developer y una unidad de Ampere. Seleccione la misma subred pública que la instancia del servidor Podman y asigne una dirección IPv4.
Decida utilizar Reglas de entrada o reenvío de puerto SSH.

Puedes acceder a la aplicación web de demostración que crearemos de dos maneras. Si bien puede activar ambos, solo necesita seleccionar uno u otro.

(Opcional) Crear una regla de entrada

El uso de una regla de entrada es un proceso de dos pasos. Esta opción abre el acceso a la subred desde Internet y sigue otorgando acceso a la instancia en el puerto especificado incluso después de un reinicio. Primero debe crear la regla en OCI y, a continuación, abrir el puerto dentro de firewalld en la instancia de Oracle Linux.

Adición de una regla de entrada a la subred pública.

La regla debe permitir el tráfico entrante en el puerto 5808/tcp desde 0.0.0.0/0. La regla se aplica inmediatamente después de la creación.
Abra un nuevo terminal y conéctese a la instancia de Oracle Cloud Developer mediante SSH.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Agregar acceso a la aplicación web de demostración.

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

Confirme los cambios en el firewall.
```
sudo firewall-cmd --list-all
```
La salida muestra ports: 5808/tcp disponible.

Usar reenvío de puerto SSH

Abra un terminal y conéctese mediante SSH a la instancia de Oracle Cloud Developer.

La opción -L permite el reenvío local, que abre un puerto local para conectarse a través de un túnel SSH a la aplicación web de demostración remota.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Creación de una imagen de contenedor para una aplicación web y ejecución local

Clone el repositorio de Git de la aplicación de demostración.

Para este tutorial, desplegará RasDash, una aplicación web de supervisión de servidor basada en Node.js.
```
git clone https://github.com/sykeben/RasDash.git
```
Cambie al directorio de código fuente.
```
cd  ~/RasDash
```

Cree un archivo de contenedor para crear y servir la aplicación 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

Cree y ejecute la imagen en la instancia local.

Cree la imagen de contenedor localmente mediante podman y etiquete la imagen con la versión de la aplicación y la arquitectura de la plataforma. Esta información será útil más adelante al transferir cada imagen de plataforma a Oracle Cloud Infrastructure Registry (OCIR) y al crear un manifiesto de las dos imágenes de plataforma.
```
sudo podman build --format docker --tag rasdash:0.3.4-arm64 .
```
La línea final será única para la creación de la aplicación.
Ejecute un contenedor con la imagen.
```
sudo podman run --rm --init -detach --name rasdash --publish 5808:5808 localhost/rasdash:0.3.4-arm64
```
El resumen que devuelve Podman es único para cada instancia de contenedor.
Consulta del contenedor en ejecución.
```
sudo podman ps
```
La salida muestra el contenedor como Up y en ejecución.
Consulte los logs de contenedor.
```
sudo podman logs rasdash
```
La salida muestra [STATE] Server started.
Ver la aplicación web.

Abra un explorador en la máquina local y vaya a http://localhost:5808. Si ha creado las reglas de entrada y firewall, puede utilizar la dirección IP pública de la instancia de Oracle Cloud Developer en lugar de localhost.

Nota: La métrica de temperatura de CPU mostrará -1, ya que las instancias virtuales de OCI no pueden acceder a los datos físicos de hardware.
Pare el contenedor en ejecución.
```
sudo podman stop rasdash
```

Configuración de SSH sin contraseña entre las instancias

Podman se comunica mediante SSH entre instancias por motivos de seguridad. Para una experiencia más fluida, cree un par de claves públicas/privadas en su instancia de Cloud Developer y cópielo en el servidor remoto de Podman para que pueda utilizar SSH desde la instancia de desarrollador sin que se le solicite una contraseña.

Genere un par de claves pública/privada en la instancia de Oracle Cloud Developer.
```
ssh-keygen -b 4096 -f ~/.ssh/id_rsa -q -N ""
```
Copie el contenido del archivo del clave pública.
```
cat ~/.ssh/id_rsa.pub
```
Seleccione la salida del comando cat y cópiela.
Cambie a la instancia del servidor Podman.
Abra el archivo en vi.
```
vi ~/.ssh/authorized_keys
```
Pegue el contenido de la clave pública en el archivo de claves autorizadas.

Guarde y cierre el archivo.
Asegúrese de aplicar los permisos correctos del sistema de archivos al directorio y los archivos SSH.
```
chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys
```
Cambie a la instancia de Cloud Developer.
Pruebe si puede utilizar SSH en el servidor Podman como usuario opc sin necesidad de una contraseña.
Nota: Si tiene algún problema, consulte la siguiente documentación:
```
ssh opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Después de haber verificado que puede conectarse sin necesidad de una contraseña, asegúrese de exit la sesión SSH entre la instancia de Oracle Cloud Developer y el servidor Podman.
Cambie a la instancia del servidor Podman.

Sustituya el archivo de claves autorizadas del usuario root.

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

Cambie a la instancia de Cloud Developer.
Pruebe si puede utilizar SSH con el usuario opc en la instancia de Cloud Developer para el usuario root en el servidor Podman.
```
ssh root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Puede exit la sesión después de probar correctamente la conexión SSH al servidor Podman como usuario raíz.

Creación de una conexión del sistema al servidor Podman

Cree una conexión del sistema Podman entre la instancia de Oracle Cloud Developer y el servicio Podman que se ejecuta en el servidor Podman.
```
sudo podman system connection add --identity ~/.ssh/id_rsa amd64 ssh://root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>/run/podman/podman.sock
```
En el comando anterior, asegúrese de sustituir <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> por la dirección IP o el nombre de host del servidor Podman.
Verifique que ha agregado correctamente la conexión.
```
sudo podman system connection list
```
La salida muestra la conexión amd64 con el valor Default definido en true. Podman utiliza esta conexión si el sistema tiene varias conexiones configuradas.

Creación de una imagen en el servidor Podman remoto

Ahora debería poder utilizar podman --remote para enviar comandos desde la instancia de Oracle Cloud Developer a la instancia remota del servidor Podman.

Pruebe obteniendo los detalles del servidor Podman.
```
sudo podman --remote info
```
La arquitectura debe informar como arm64.

Cree la imagen remota.

Podman copiará todo el contexto en la instancia remota automáticamente.

cd ~/RasDash
sudo podman --remote build --format docker --tag rasdash:0.3.4-amd64 .

Verifique que la imagen existe en el servidor Podman remoto.

NOTA: Podman no copia la imagen que crea de nuevo en el equipo cliente, por lo que la imagen no se mostrará si ejecuta sudo podman images. Sin embargo, está disponible en la máquina remota.
```
sudo podman --remote images
```
Salida de ejemplo:
```
REPOSITORY                          TAG          IMAGE ID      CREATED        SIZE
localhost/rasdash                   0.3.4-amd64  3a1b9755ebdd  8 seconds ago  439 MB
...
```
Verifique la arquitectura de la imagen local.

El método final para validar que cada imagen se ha creado para (y sobre) una plataforma y arquitectura específicas utiliza jq para extraer el valor del campo Architecture en el manifiesto de cada imagen.
```
sudo podman inspect rasdash:0.3.4-arm64 | jq -r '.[] | .Architecture'
```
La imagen local informa su arquitectura como arm64.

Compruebe la imagen remota.

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

La imagen remota se informa como amd64.

Creación de un repositorio de Container Registry

En la consola de Oracle Cloud Infrastructure, vaya a la sección Container Registry y cree un repositorio para almacenar la aplicación multiplataforma.

Para obtener más información, consulte Creación de un repositorio en la documentación de Oracle Cloud Infrastructure.

Cree el repositorio demo/rasdash privado.
Revise los detalles del nuevo repositorio

Recopilar las credenciales del repositorio de Container Registry

En la siguiente tabla se proporcionan valores de ejemplo que se utilizan en pasos posteriores de este tutorial. El ejemplo iad es la clave de región para la región Este de EE. UU. (Ashburn). Si su región es Alemania Central (Fráncfort), la clave de región es fra. Consulte la documentación de regiones y dominios de disponibilidad para obtener una tabla completa con las claves de región disponibles.

Datos de registro	Marcador de posición del tutorial	Notas:
REGISTRY_NAMESPACE	`gse00015915`	Se muestra en el panel de información del repositorio como "Namespace"
REPOSITORY_NAME	`demo/rasdash`	Se muestra bajo el nombre del compartimento
OCIR_INSTANCE	`iad.ocir.io`	Utilice `<region>.ocir.io`

Si es necesario, consulte Transferencia de imágenes con la CLI de Docker. Este procedimiento describe el proceso de inicio de sesión necesario para transferir imágenes a Container Registry mediante la CLI.

Obtenga su nombre de usuario.

Necesita un nombre de usuario y un token de autenticación para conectarse al registro de contenedores. Para obtener el nombre de usuario, en la esquina superior derecha de la consola de Oracle Cloud Infrastructure, abra el menú Perfil (icono de menú Usuario) y, a continuación, haga clic en Mi perfil para ver los detalles.

Copie y guarde el nombre de usuario, incluido tenancy-namespace que se muestra en la consola.
Genere un token de autenticación.

Desplácese por la página Mi perfil en la consola y seleccione Tokens de autenticación en Recursos.

Seleccione el botón Generar token y proporcione una descripción de demo para el nuevo token.

Después de generar el token, asegúrese de copiarlo y guardarlo.

En la siguiente tabla se proporcionan valores de ejemplo que se utilizan en pasos posteriores de este tutorial.

Nombre de usuario	Marcador de posición del tutorial
REGISTRY_NAMESPACE	`gse00015915`
USERNAME	`luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e`
TOKEN (TOKEN)	`]y#W_iS9GKC}4l1Gq9Fn`
OCIR_INSTANCE	`iad.ocir.io`

Cree variables de entorno para utilizarlas en el comando podman login.

Cree las variables de entorno USER y TOKEN mediante el nombre de usuario y el token. Asegúrese de incluir <REGISTRY_NAMESPACE> como parte del nombre de usuario.

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"

Inicie sesión en el registro de contenedores.
```
sudo -E podman login -u $OCIR_USERNAME -p $OCIR_USER_TOKEN $OCIR_INSTANCE
```
La instancia remota heredará automáticamente las credenciales de autenticación de la instancia de cliente.

Transfiera las imágenes de la plataforma

En este ejemplo, los URI de repositorio finales con etiquetas específicas de la plataforma son:

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

Podman puede transferir imágenes locales a registros remotos sin que la imagen deba etiquetarse de antemano.

Transfiera la imagen 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

Transfiera la imagen 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

Compruebe la consola de Container Registry.

Nota: La transferencia de una imagen remota no genera una salida local. Revise la consola de Container Registry para la etiqueta rasdash:0.3.4-amd64 para comprobar si ha transferido correctamente la imagen.

Debería ver dos imágenes en la consola de Container Registry.

La imagen 0.3.4-amd64:

La imagen 0.3.4-arm64:

Creación y transferencia de una lista de manifiestos a Container Registry

Ahora que tiene dos imágenes de plataforma, es hora de crear una lista de manifiestos para permitir que los tiempos de ejecución de contenedores seleccionen la imagen adecuada para su plataforma, que es una combinación del sistema operativo y la arquitectura.

Debido a que la mayoría de las imágenes de contenedor están basadas en Linux, los usuarios suelen hacer referencia a una imagen multiplataforma como una imagen multiarchivo. Sin embargo, también es posible combinar imágenes que se puedan ejecutar en Windows, macOS y Linux en un solo manifiesto.

Cree y rellene el manifiesto.

Cree una lista de manifiestos local en la instancia de Cloud Developer con solo la versión de la aplicación en la etiqueta.
```
sudo podman manifest create rasdash:0.3.4
```
Como antes, la salida del total de control es única para el manifiesto que crea y no coincidirá con la anterior.
Inspeccione la lista de manifiestos para revelar lo que se está utilizando mediaType y sus imágenes de miembros.
```
sudo podman manifest inspect rasdash:0.3.4
```

Agregue las dos imágenes específicas de la plataforma a la 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

Inspeccione la lista de manifiestos.
```
sudo podman manifest inspect rasdash:0.3.4
```
La salida es más interesante después de agregar las imágenes.

Para obtener la máxima compatibilidad, ha agregado el parámetro --format docker a cada comando de compilación, que indica a Podman que cree la imagen mediante la especificación Manifiesto de imagen de Docker V2, Esquema 2 (v2s2) en lugar de la Especificación de manifiesto de imagen de Open Container Initiative, que Podman utilizará por defecto.

Debido a que los manifiestos utilizan la especificación v2s2, Podman utiliza la especificación v2s2 Lista de manifiestos asociada en lugar de la especificación Open Container Initiative Image Index Specification.

Los tiempos de ejecución de contenedor por defecto utilizados por los servicios gestionados de Kubernetes basados en la nube, incluidas Oracle Engine for Kubernetes (OKE) y las distribuciones locales de Kubernetes autoalojadas, son compatibles con ambas especificaciones.
Transfiera la lista de manifiestos a Container Registry.

Ahora que ha creado la lista de manifiestos, puede transferirla al mismo repositorio de Container Registry que almacena las imágenes específicas de la plataforma.
```
sudo -E podman manifest push --all rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```
Esta acción es una operación rápida porque ha enviado las imágenes específicas de la plataforma anteriormente. Container Registry solo enlaza la lista de manifiestos a las imágenes existentes.
Cree y ejecute la imagen localmente.

Ahora puede ejecutar una instancia de la imagen de forma local y remota mediante la etiqueta de lista de manifiestos en lugar de la etiqueta específica de la plataforma.
```
sudo -E podman run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```

Cree y ejecute la imagen de forma remota.

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

Prueba de las imágenes mediante un explorador

Supongamos que ha creado las reglas de entrada y las reglas de firewall necesarias en las instancias. En ese caso, debe poder abrir el explorador y navegar a http://<PUBLIC_IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>:5808 y http://<PUBLIC_IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>:5808 para abrir la aplicación web RasDash que se ejecuta en cada instancia.

De lo contrario, puede utilizar el reenvío de puertos SSH como antes creando dos túneles desde la máquina local.

Abra un túnel SSH a la instancia de Oracle Cloud Developer.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```
Abra un explorador en la máquina local y vaya a http://localhost:5808 para ver la aplicación web basada en arm64 en la instancia de Cloud Development.
Salga de la sesión de túnel SSH.
Abra un túnel SSH a la instancia del servidor Podman.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Refresque el explorador en la máquina local que apunta a http://localhost:5808 para ver la aplicación web basada en amd64 en la instancia del servidor Podman.

Pasos Siguientes

Después de completar este tutorial, ahora debe saber cómo crear imágenes que puede desplegar desde los repositorios OCIR privados y públicos. Puede utilizar estas imágenes en varias ubicaciones, como Oracle Engine for Kubernetes (OKE) u Oracle Cloud Native Environment. Al desplegar las imágenes en hosts fuera de Oracle Cloud Infrastructure, incluido Podman Desktop para Mac o Windows, debe asegurarse de que el repositorio es público.

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Build Multi-Platform Container Images Using Podman on Oracle Linux

F49996-04

Oracle y/o sus filiales.