Créer des images de conteneur multiplateforme à l'aide de Podman sur Oracle Linux

Présentation

Cette démo présente la création d'une image de conteneur multiplateforme à l'aide de Podman sur Oracle Linux.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Configurer Podman pour la connectivité distante
Se connecter à une instance Podman distante
Créer des images propres à une plate-forme à partir d'un seul fichier conteneur
Pousser des images propres à la plate-forme vers Oracle Cloud Infrastructure Registry (OCIR)
Créer une liste de manifestes comprenant les deux images propres à la plate-forme
Pousser la liste de manifestes vers OCIR
Examinez la liste des manifestes hébergés par OCIR pour voir les plates-formes disponibles
Tirez et exécutez l'image

Préalables

Accès à une location Oracle Cloud Infrastructure (OCI)
Une instance Oracle Linux x86_64
Une instance aarch_64 pour les développeurs Oracle Cloud
Accès à Oracle Cloud Infrastructure Registry

Déployer un serveur Podman

Créez une instance de calcul Oracle Linux.

Vous pouvez utiliser l'image et la forme par défaut, à condition que la forme utilise une architecture x86_64. Sélectionnez ou créez un sous-réseau public et affectez une adresse IPv4.

Cette étape prend en charge l'utilisation des formes Micro disponibles dans le niveau Toujours gratuit.
Une fois l'instance en cours d'exécution, connectez-vous à l'instance.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Où :
- <SSH_KEY> est la partie privée de votre clé SSH utilisée lors du provisionnement de l'instance de calcul. Exemple : ~/.ssh/id_rsa
- <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> est l'adresse IP publique de l'instance de calcul.

Installer et configurer Podman pour l'accès distant

Vous pouvez exécuter ces commandes en tant que compte d'utilisateur opc par défaut sur l'instance de calcul ou tout utilisateur disposant d'un accès sudo.

Mettez à jour le système avec tous les derniers correctifs de sécurité et errata.
```
sudo dnf -y update
```
Installez les packages ou modules Podman.

Oracle Linux 8 :
```
sudo dnf module install -y container-tools:ol8
```
Oracle Linux 9 et Oracle Linux 10 :
```
sudo dnf install -y container-tools
```
Le module ou le package container-tools installe podman et d'autres outils container, y compris skopeo et buildah. Un ensemble essentiel est container-selinux, qui permet d'exécuter podman en tant qu'utilisateur non racine sur un système activé pour SELinux, ce qu'Oracle Linux active par défaut.
Activez le connecteur logiciel Podman.

systemd écoutera sur ce socket et déclenchera une instance de Podman chaque fois qu'un client distant l'activera. Lorsque la connexion se ferme, systemd arrête l'instance Podman.

Note : Il est possible de configurer l'accès Podman distant en mode sans racine, mais cela dépasse la portée de ce tutoriel.
```
sudo systemctl enable --now podman.socket
```
Vérifiez le chemin d'accès au connecteur logiciel.
```
sudo systemctl status podman.socket
```
La sortie affiche l'écoute du connecteur logiciel et son emplacement est à /run/podman/podman.sock.

C'est tout, mais restez connecté à l'instance de serveur Podman pour effectuer une configuration SSH sans mot de passe plus tard dans ce tutoriel.

Déployer une instance Oracle Cloud Developer

Le service de calcul d'Oracle Ampere A1 est une plate-forme haute performance combinant les processeurs Oracle Cloud Infrastructure (OCI) et Ampere Altra Arm. Il fournit une performance déterministe, une sécurité éprouvée et un vaste écosystème de développeurs qui comprend des outils et des environnements populaires (système d'exploitation, Kubernetes - OKE, trousses SDK et interfaces de ligne de commande).

OCI répertorie l'image Oracle Cloud Developer en tant qu'image de plate-forme avec tous les outils de développement populaires installés, notamment Git, Node.js, Java et GraalVM.

Créez une instance de calcul Oracle Cloud Developer.

Sélectionnez l'image Oracle Cloud Developer et une forme Ampere. Sélectionnez le même sous-réseau public que l'instance de serveur Podman et affectez une adresse IPv4.
Décidez d'utiliser des règles de trafic entrant ou le transfert de port SSH.

Vous pouvez accéder à l'application Web de démonstration que nous allons créer de deux façons. Bien que vous puissiez activer les deux, vous n'avez qu'à choisir l'un ou l'autre.

(Facultatif) Créer une règle de trafic entrant

L'utilisation d'une règle de trafic entrant est un processus en deux étapes. Cette option ouvre l'accès au sous-réseau à partir d'Internet et continue d'accorder l'accès à l'instance sur le port spécifié, même après un redémarrage. Vous devez d'abord créer la règle dans OCI, puis ouvrir le port dans firewalld sur l'instance Oracle Linux.

Ajoutez une règle de trafic entrant à votre sous-réseau public.

La règle doit autoriser le trafic entrant sur le port 5808/tcp à partir de 0.0.0.0/0. La règle prend effet immédiatement après sa création.
Ouvrez un nouveau terminal et connectez-vous à l'instance Oracle Cloud Developer au moyen de SSH.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Ajouter un accès à l'application Web de démonstration.

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

Vérifiez les modifications apportées au pare-feu.
```
sudo firewall-cmd --list-all
```
La sortie affiche ports: 5808/tcp disponible.

Utiliser le transfert de port SSH

Ouvrez un terminal et connectez-vous au moyen de SSH à l'instance Oracle Cloud Developer.

L'option -L active le transfert local, qui ouvre un port local pour se connecter au moyen d'un tunnel SSH à l'application Web de démonstration distante.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Créer une image de conteneur pour une application Web et l'exécuter localement

Cloner le référentiel Git de l'application de démonstration.

Pour ce tutoriel, vous allez déployer RasDash, une application Web de surveillance de serveur basée sur Node.js.
```
git clone https://github.com/sykeben/RasDash.git
```
Accédez au répertoire du code source.
```
cd  ~/RasDash
```

Créez un fichier de conteneur pour créer et servir l'application 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

Créez et exécutez l'image sur l'instance locale.

Créez l'image de conteneur localement à l'aide de podman et marquez-la avec la version de l'application et l'architecture de la plate-forme. Ces informations vous seront utiles plus tard lorsque vous pousserez chaque image de plate-forme vers Oracle Cloud Infrastructure Registry (OCIR) et lorsque vous créerez un manifeste des deux images de plate-forme.
```
sudo podman build --format docker --tag rasdash:0.3.4-arm64 .
```
La ligne finale sera unique à la création de votre application.
Exécutez un conteneur à l'aide de l'image.
```
sudo podman run --rm --init -detach --name rasdash --publish 5808:5808 localhost/rasdash:0.3.4-arm64
```
Le condensé retourné par Podman est unique à chaque instance de conteneur.
Affichez le conteneur en cours d'exécution.
```
sudo podman ps
```
La sortie affiche le conteneur comme Up et en cours d'exécution.
Consultez les journaux de conteneur.
```
sudo podman logs rasdash
```
La sortie affiche [STATE] Server started.
Voir l'application Web.

Ouvrez un navigateur sur votre ordinateur local et accédez à http://localhost:5808. Si vous avez créé les règles de trafic entrant et de pare-feu, vous pouvez utiliser l'adresse IP publique de l'instance de développeur Oracle Cloud plutôt que localhost.

Note : La mesure de température de l'UC affichera -1 car les instances virtuelles dans OCI ne peuvent pas accéder aux données matérielles physiques.
Arrêtez le conteneur en cours d'exécution.
```
sudo podman stop rasdash
```

Configurer SSH sans mot de passe entre les instances

Podman communique à l'aide de SSH entre les instances à des fins de sécurité. Pour une expérience plus transparente, créez une paire de clés publique/privée sur votre instance de développeur en nuage et copiez-la sur le serveur distant Podman afin de pouvoir utiliser SSH à partir de l'instance de développeur sans être invité à entrer un mot de passe.

Générez une paire de clés publique/privée sur l'instance Oracle Cloud Developer.
```
ssh-keygen -b 4096 -f ~/.ssh/id_rsa -q -N ""
```
Copier le contenu du fichier de clé publique.
```
cat ~/.ssh/id_rsa.pub
```
Sélectionnez la sortie de la commande cat et copiez-la.
Passez à l'instance de serveur Podman.
Ouvrir le fichier en vi.
```
vi ~/.ssh/authorized_keys
```
Collez le contenu de la clé publique dans le fichier de clés autorisées.

Enregistrez le fichier et fermez-le.
Assurez-vous d'appliquer les autorisations de système de fichiers appropriées au répertoire et aux fichiers SSH.
```
chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys
```
Passez à l'instance Cloud Developer.
Testez si vous pouvez accéder au serveur Podman en tant qu'utilisateur opc sans avoir besoin d'un mot de passe.
Note : En cas de problème, consultez la documentation suivante :
```
ssh opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Une fois que vous avez vérifié que vous pouvez vous connecter sans avoir besoin d'un mot de passe, veillez à exit la session SSH entre l'instance Oracle Cloud Developer et le serveur Podman.
Passez à l'instance de serveur Podman.

Remplacez le fichier de clés autorisées de l'utilisateur racine.

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

Passez à l'instance Cloud Developer.
Testez si vous pouvez utiliser SSH avec l'utilisateur opc dans l'instance Cloud Developer pour l'utilisateur root sur le serveur Podman.
```
ssh root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Vous pouvez exit la session après avoir testé avec succès la connexion SSH au serveur Podman en tant qu'utilisateur racine.

Créer une connexion système au serveur Podman

Créez une connexion système Podman entre l'instance Oracle Cloud Developer et le service Podman s'exécutant sur votre serveur Podman.
```
sudo podman system connection add --identity ~/.ssh/id_rsa amd64 ssh://root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>/run/podman/podman.sock
```
Dans la commande ci-dessus, veillez à remplacer <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> par l'adresse IP ou le nom d'hôte de votre serveur Podman.
Vérifiez que la connexion a été ajoutée.
```
sudo podman system connection list
```
La sortie affiche la connexion amd64 avec la valeur Default réglée à true. Podman utilise cette connexion si plusieurs connexions sont configurées pour le système.

Créer une image sur le serveur Podman distant

Vous devriez maintenant pouvoir utiliser podman --remote pour envoyer des commandes de l'instance Oracle Cloud Developer à l'instance de serveur Podman distante.

Testez en obtenant les détails du serveur Podman.
```
sudo podman --remote info
```
L'architecture doit indiquer arm64.
Créez l'image distante.

Podman copiera automatiquement l'intégralité du contexte dans l'instance distante.
```
cd ~/RasDash
sudo podman --remote build --format docker --tag rasdash:0.3.4-amd64 .
```
Vérifiez que l'image existe sur le serveur Podman distant.

REMARQUE : Podman ne copie pas l'image qu'il crée sur l'ordinateur client, de sorte que l'image ne sera pas répertoriée si vous exécutez sudo podman images. Cependant, il est disponible sur la machine distante.
```
sudo podman --remote images
```
Exemple de sortie :
```
REPOSITORY                          TAG          IMAGE ID      CREATED        SIZE
localhost/rasdash                   0.3.4-amd64  3a1b9755ebdd  8 seconds ago  439 MB
...
```
Vérifiez l'architecture d'image locale.

La méthode finale pour valider que chaque image a été créée pour (et sur) une plate-forme et une architecture spécifiques utilise jq pour extraire la valeur du champ Architecture dans le manifeste de chaque image.
```
sudo podman inspect rasdash:0.3.4-arm64 | jq -r '.[] | .Architecture'
```
L'image locale indique son architecture comme arm64.

Vérifiez l'image distante.

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

L'image distante indique amd64.

Créer un référentiel de registre de conteneurs

Dans la console Oracle Cloud Infrastructure, naviguez jusqu'à la section Registre de conteneurs et créez un référentiel pour stocker votre application multiplateforme.

Pour plus de détails, voir Création d'un référentiel dans la documentation sur Oracle Cloud Infrastructure.

Créez le référentiel demo/rasdash privé.
Vérifiez les détails du nouveau référentiel.

Collecter les données d'identification du référentiel du registre de conteneurs

Le tableau suivant présente des exemples de valeurs utilisées dans les étapes suivantes de ce tutoriel. L'exemple iad est la clé de région pour la région États-Unis - Est (Ashburn). Si votre région est Centre de l'Allemagne (Francfort), la clé de région est fra. Consultez la documentation sur les régions et domaines de disponibilité pour obtenir une liste complète des clés de région disponibles dans le tableau.

Données du registre	Paramètre fictif du tutoriel	Notes
REGISTRY_NAMESPACE	`gse00015915`	Affiché dans le panneau d'informations du référentiel sous "Espace de noms"
REPOSITORY_NAME	`demo/rasdash`	Affiché sous le nom du compartiment
OCIR_INSTANCE	`iad.ocir.io`	Utiliser `<region>.ocir.io`

Voir Transmission d'images à l'aide de l'interface de ligne de commande Docker si nécessaire. Cette procédure décrit le processus de connexion requis pour pousser des images vers le registre de conteneurs à l'aide de l'interface de ligne de commande.

Obtenez votre nom d'utilisateur.

Vous avez besoin d'un nom d'utilisateur et d'un jeton d'authentification pour vous connecter au registre de conteneurs. Pour obtenir le nom d'utilisateur, dans le coin supérieur droit de la console Oracle Cloud Infrastructure, ouvrez le menu Profil (icône de menu d'utilisateur), puis cliquez sur Mon profil pour en voir les détails.

Copiez et enregistrez le nom d'utilisateur, y compris tenancy-namespace affiché dans la console.
Générer un jeton d'authentification.

Faites défiler la page Mon profil dans la console et sélectionnez Jetons d'authentification sous Ressources.

Sélectionnez le bouton Générer un jeton et fournissez une description de demo pour le nouveau jeton.

Après avoir généré le jeton, veillez à le copier et à l'enregistrer.

Le tableau suivant présente des exemples de valeurs utilisées dans les étapes suivantes de ce tutoriel.

Nom d'utilisateur	Paramètre fictif du tutoriel
REGISTRY_NAMESPACE	`gse00015915`
NOM D'UTILISATEUR	`luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e`
JETON	`]y#W_iS9GKC}4l1Gq9Fn`
OCIR_INSTANCE	`iad.ocir.io`

Créez des variables d'environnement à utiliser dans la commande podman login.

Créez les variables d'environnement USER et TOKEN à l'aide de votre nom d'utilisateur et de votre jeton. Assurez-vous d'inclure <REGISTRY_NAMESPACE> dans le nom d'utilisateur.
```
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"
```
Connectez-vous au registre de conteneurs.
```
sudo -E podman login -u $OCIR_USERNAME -p $OCIR_USER_TOKEN $OCIR_INSTANCE
```
L'instance distante héritera automatiquement des données d'identification d'authentification de l'instance client.

Pousser les images de plate-forme

Dans cet exemple, les URI de référentiel finaux avec des marqueurs propres à la plate-forme sont les suivants :

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

Podman peut pousser des images locales vers des registres distants sans que l'image ait besoin d'être préalablement marquée.

Poussez l'image rasdash/0.3.4-arm64 locale.

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

Pousser l'image rasdash:0.3.4-amd64 distante.

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

Vérifiez la console du registre de conteneurs.

Note : La transmission d'une image distante ne génère pas de sortie locale. Vérifiez dans la console du registre de conteneurs le marqueur rasdash:0.3.4-amd64 pour vérifier si vous avez poussé l'image avec succès.

Vous devez voir deux images dans la console du registre de conteneurs.

L'image 0.3.4-amd64 :

L'image 0.3.4-arm64 :

Créer et pousser une liste de manifestes vers le registre de conteneurs

Maintenant que vous disposez de deux images de plate-forme, il est temps de créer une liste de manifestes pour permettre aux environnements d'exécution de conteneur de sélectionner l'image appropriée pour leur plate-forme, qui est une combinaison du système d'exploitation et de l'architecture.

Comme la plupart des images de conteneur sont basées sur Linux, les utilisateurs font généralement référence à une image multiplateforme en tant qu'image multi-archives. Cependant, la combinaison d'images pouvant s'exécuter sous Windows, macOS et Linux dans un seul manifeste est également possible.

Créez et alimentez le manifeste.

Créez une liste de manifestes locale sur l'instance de développeur en nuage avec uniquement la version de l'application dans le marqueur.
```
sudo podman manifest create rasdash:0.3.4
```
Comme précédemment, la sortie de somme de contrôle est unique au manifeste que vous créez et ne correspond pas à celui ci-dessus.
Inspectez la liste de manifestes pour révéler ce que mediaType est utilisé et ses images de membre.
```
sudo podman manifest inspect rasdash:0.3.4
```

Ajoutez les deux images propres à la plate-forme à la liste.

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

Examinez la liste des manifestes.
```
sudo podman manifest inspect rasdash:0.3.4
```
La sortie est plus intéressante après l'ajout des images.

Pour une compatibilité maximale, vous avez ajouté le paramètre --format docker à chaque commande de compilation, qui indique à Podman de créer l'image à l'aide de la spécification de manifeste d'image Docker V2, schéma 2 (v2s2) au lieu de la spécification de manifeste d'image Open Container Initiative, que Podman utilisera par défaut.

Comme les manifestes utilisent la spécification v2s2, Podman utilise la spécification v2s2 Manifest List (Liste de manifestes) associée au lieu de la spécification Open Container Initiative Image Index Specification.

Les exécutions de conteneur par défaut utilisées par les services Kubernetes gérés en nuage, notamment Oracle Engine for Kubernetes (OKE) et les répartitions Kubernetes auto-hébergées sur place, sont compatibles avec les deux spécifications.
Pousser la liste de manifestes vers le registre de conteneurs.

Maintenant que vous avez créé la liste de manifestes, vous pouvez la pousser vers le même référentiel de registre de conteneurs qui stocke les images propres à la plate-forme.
```
sudo -E podman manifest push --all rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```
Cette action est rapide car vous avez poussé les images propres à la plate-forme plus tôt. Le registre de conteneurs lie simplement la liste de manifestes aux images existantes.
Créez et exécutez l'image localement.

Vous pouvez maintenant exécuter une instance de l'image localement et à distance à l'aide de la balise de liste de manifestes au lieu de la balise propre à la plate-forme.
```
sudo -E podman run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```

Créez et exécutez l'image à distance.

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

Tester les images à l'aide d'un navigateur

Supposons que vous ayez créé les règles entrantes et les règles Firewalld nécessaires sur les instances. Dans ce cas, vous devriez pouvoir ouvrir votre navigateur et naviguer jusqu'à http://<PUBLIC_IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>:5808 et http://<PUBLIC_IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>:5808 pour ouvrir l'application Web RasDash s'exécutant sur chaque instance.

Sinon, vous pouvez utiliser le transfert de port SSH comme précédemment en créant deux tunnels à partir de votre machine locale.

Ouvrez un tunnel SSH vers l'instance Oracle Cloud Developer.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```
Ouvrez un navigateur sur votre machine locale et naviguez jusqu'à http://localhost:5808 pour voir l'application Web basée sur arm64 sur l'instance de développement en nuage.
Quittez la session de tunnel SSH.
Ouvrez un tunnel SSH vers l'instance de serveur Podman.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Actualisez le navigateur sur votre machine locale en pointant vers http://localhost:5808 pour voir l'application Web basée sur amd64 sur l'instance du serveur Podman.

Étapes suivantes

Après avoir terminé ce tutoriel, vous devez maintenant savoir comment créer des images que vous pouvez déployer à partir de référentiels OCIR privés et publics. Vous pouvez utiliser ces images dans divers emplacements, tels que Oracle Engine for Kubernetes (OKE) ou Oracle Cloud Native Environment. Lors du déploiement de vos images sur des hôtes en dehors d'Oracle Cloud Infrastructure, y compris Podman Desktop pour Mac ou Windows, vous devez vous assurer que le référentiel est public.

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.

Titre et informations sur les droits d'auteur

Build Multi-Platform Container Images Using Podman on Oracle Linux

G45266-01

Oracle et/ou ses sociétés affiliées.