Remarques :

Déployer des charges de travail Kubernetes à l'aide de Podman avec Oracle Cloud Native Environment

Introduction

Podman kube offre aux développeurs et aux administrateurs un moyen de tester les charges de travail Kubernetes à l'aide de Podman avant de les déployer vers un cluster Kubernetes. La commande podman kube est utilisée pour générer des YAML conformes à Kubernetes à partir de conteneurs ou pods Podman existants ou pour créer des conteneurs/pods à partir d'un fichier YAML Kubernetes. Il s'agit d'un moyen pratique de passer facilement d'un environnement Podman à un environnement Kubernetes, en tirant parti du meilleur des deux écosystèmes pour réduire les cycles de développement et de test.

Remarque : la commande podman kube play lit tout fichier YAML Kubernetes valide et démarre les pods, conteneurs ou volumes définis dans le fichier YAML sur votre instance Podman en cours d'exécution locale. Cependant, tous les types de fichier YAML Kubernetes ne sont pas pris en charge ; les types Kubernetes actuellement pris en charge sont les suivants :

Une liste plus détaillée des champs YAML Kubernetes actuellement pris en charge par la commande podman kube play est disponible ici.

Podman peut appliquer les fichiers YAML Kubernetes pris en charge à un cluster Kubernetes à l'aide de la commande podman kube apply. Ces étapes fonctionnent avec n'importe quel cluster Kubernetes. Cependant, nous recommandons Oracle Cloud Native Environment comme option de déploiement Kubernetes. Pour plus d'informations, reportez-vous à la documentation Oracle Cloud Native Environment.

Remarque : ce tutoriel présente l'utilisation de Podman pour générer des fichiers YAML Kubernetes, puis explique comment les déployer vers un cluster Kubernetes. Toute gestion ultérieure des objets déployés doit être effectuée à l'aide des commandes kubectl. Pour plus d'informations sur l'utilisation de kubectl, reportez-vous à la documentation en amont.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

Prérequis

Configuration d'Oracle Cloud Native Environment

Remarque : si vous êtes en cours d'exécution dans votre propre location, lisez le projet linux-virt-labs GitHub README.md et complétez les prérequis avant de déployer l'environnement d'exercice.

  1. Ouvrez un terminal sur le bureau Luna.

  2. Clonez le projet linux-virt-labs GitHub.

    git clone https://github.com/oracle-devrel/linux-virt-labs.git

  3. Accédez au répertoire de travail.

    cd linux-virt-labs/ocne2

  4. Installez les ensembles requis.

    ansible-galaxy collection install -r requirements.yml

  5. Déployez l'environnement d'exercice.

    ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e use_podman=true -e install_ocne_rpm=true -e create_ocne_cluster=true -e "ocne_cluster_node_options='-n 1 -w 1'"

    L'environnement d'exercice libre requiert la variable supplémentaire local_python_interpreter, qui définit ansible_python_interpreter pour les lectures exécutées sur localhost. Cette variable est nécessaire car l'environnement installe le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python, situé sous les modules python3.6.

    La forme de déploiement par défaut utilise l'UC AMD et Oracle Linux 8. Pour utiliser une CPU Intel ou Oracle Linux 9, ajoutez -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" à la commande de déploiement.

    Important : attendez que le guide de lecture s'exécute correctement et atteignez la tâche de pause. A ce stade du manuel, l'installation du CNE Oracle est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui affiche les adresses IP publiques et privées des noeuds qu'elle déploie et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Accéder au cluster Kubernetes

  1. Ouvrez un terminal et connectez-vous via SSH à l'instance ocne.

    ssh oracle@<ip_address_of_instance>

  2. Attendez que le cluster se stabilise et que tous les pods signalent leur exécution.

    watch kubectl get pods -A

    Une fois que tous les pods affichent le STATUS de Running, saisissez Ctrl-C pour quitter la commande watch.

  3. Vérifiez le nombre de noeuds présents.

    kubectl get nodes

Confirmer le fonctionnement de Podman

  1. Vérification de la version de Podman.

    podman -v

  2. Vérifiez que l'interface de ligne de commande Podman fonctionne.

    podman run quay.io/podman/hello

    Exemple de résultat :

    [oracle@ol-server ~]$ podman run quay.io/podman/hello
Trying to pull quay.io/podman/hello:latest...
Getting image source signatures
Copying blob f82b04e85914 done
Copying config dbd85e09a1 done
Writing manifest to image destination
Storing signatures
!... Hello Podman World ...!

         .--"--.
       / -     - \
      / (O)   (O) \
   ~~~| -=(,Y,)=- |
    .---. /`  \   |~~
 ~/  o  o \~~~~.----. ~~
  | =(X)= |~  / (O (O) \
   ~~~~~~~  ~| =(Y_)=-  |
  ~~~~    ~~~|   U      |~~

Project:   https://github.com/containers/podman
Website:   https://podman.io
Documents: https://docs.podman.io
Twitter:   @Podman_io

Créer les fichiers YAML Kubernetes

La fonctionnalité Podman Kube peut fonctionner avec des fichiers YAML Kubernetes générés par Podman ou avec des fichiers YAML Kubernetes natifs. Regardons les deux à leur tour.

Création d'un pod Podman avec un conteneur et génération de Kubernetes YAML

Tout d'abord, déployez un conteneur dans un pod Podman localement. Utilisez ensuite le déploiement pour générer un fichier YAML Kubernetes qui peut être déployé sur un cluster Kubernetes.

  1. Créez un pod avec un serveur Nginx qui mappe le port 8081 avec l'hôte.

    podman run -dt --pod new:my-nginx --name nginx-container -p 8081:80 ghcr.io/oracle/oraclelinux9-nginx:1.20

    Cela crée un pod nommé 'my-nginx', déploie un conteneur Nginx à l'intérieur du pod et met en correspondance le conteneur avec le port 8081 sur l'hôte.

  2. Vérifiez que le pod a été créé.

    podman pod ps

    Exemple de résultat :

    [oracle@ocne ~]$ podman pod ps
POD ID        NAME        STATUS      CREATED         INFRA ID      # OF CONTAINERS
e5248f6968b3  my-nginx    Running     48 seconds ago  5e41ad85e232  2

  3. Vérifiez que vous pouvez accéder au nouveau pod et à son conteneur à partir de l'hôte.

    curl http://localhost:8081

  4. Générez un fichier Kubernetes YAML à partir du pod en cours d'exécution.

    podman kube generate my-nginx --type pod > nginx-pod.yaml

    La commande Podman generate crée un fichier compatible Kubernetes à partir d'un pod Podman en cours d'exécution avec des conteneurs. Le rendant très utile pour le prototypage local, puis la création d'un fichier manifeste compatible Kubernetes, vous pouvez le déployer vers un cluster Kubernetes.

  5. Vérifiez le fichier généré.

    cat nginx-pod.yaml

    Exemple de résultat :

    [oracle@ocne ~]$ cat nginx-pod.yaml
# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-4.9.4-rhel
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: "2025-08-11T14:08:13Z"
  labels:
    app: my-nginx
  name: my-nginx
spec:
  containers:
  - env:
    - name: TERM
      value: xterm
    image: ghcr.io/oracle/oraclelinux9-nginx:1.20
    name: zenbardeen
    ports:
    - containerPort: 80
      hostPort: 8081
    tty: true

Suppression du pod et des conteneurs déployés à l'aide de Podman Kube

Les pods et leurs conteneurs associés peuvent être enlevés facilement une fois que vous avez fini de travailler avec eux.

  1. Supprimez le pod my-nginx.

    podman kube down nginx-pod.yaml

  2. Vérifiez que les deux pods ont été supprimés.

    podman pod ps

    Exemple de résultat :

    [oracle@ocne ~]$ podman pod ps
POD ID      NAME        STATUS      CREATED     INFRA ID    # OF CONTAINERS

    Cela confirme que le fichier YAML Kubernetes généré par Podman que vous avez créé précédemment est valide.

Utilisation de Podman Kube pour déployer Kubernetes YAML sur un cluster Kubernetes

Podman ne peut être déployé vers un cluster Kubernetes que si votre hôte dispose d'un fichier kubeconfig valide situé dans le répertoire $HOME/.kube.

Confirmer la validité de votre environnement

  1. Vérifiez que la variable d'environnement KUBECONFIG est définie.

    env | grep KUBE

    Exemple de résultat :

    [oracle@ocne ~]$ env | grep KUBE
KUBECONFIG=/home/oracle/.kube/kubeconfig.ocne.local

    Informations : si kubectl est installé et que le répertoire ${HOME}/.kube contient plusieurs fichiers de configuration, exécutez cette commande pour confirmer quel fichier de configuration est actuellement utilisé par kubectl :

    kubectl get pod  -v6 2>&1 | awk '/Config loaded from file:/{print $NF}'

    Exemple de résultat :

    [oracle@ocne ~]$ kubectl get pod  -v6 2>&1 | awk '/Config loaded from file:/{print $NF}'
/home/oracle/.kube/kubeconfig.ocne.local

    Remarque : exécutez n'importe quelle commande kubectl avec verbosity défini sur le niveau 6 ou supérieur, et le fichier kubeconfig en cours d'utilisation est inclus dans la sortie.

Déployer un fichier YAML Kubernetes valide

  1. Créez un fichier YAML Kubernetes.

    cat << EOF | tee testpod.yaml > /dev/null
apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: test-container
    image: ghcr.io/oracle/oraclelinux9-nginx:1.20
    ports:
    - containerPort: 8080
EOF

  2. Utilisez Podman pour déployer le fichier testpod.yaml vers votre cluster Kubernetes.

    podman kube apply -f testpod.yaml

    Exemple de résultat :

    [oracle@ocne ~]$ podman kube apply -f testpod.yaml
Deploying to cluster...
Successfully deployed workloads to cluster!

    Remarque : cette option est déployée vers l'espace de noms default par défaut.

  3. Vérifiez que le pod est déployé sur votre cluster.

    kubectl get pods

    Exemple de résultat :

    [oracle@ocne ~]$ kubectl get pods
NAME      READY   STATUS    RESTARTS   AGE
my-pod    1/1     Running   0          23s

    Cela confirme que podman a déployé un pod appelé 'my-pod' sur le cluster.

  4. Vérifiez que Nginx est déployé comme prévu.

    kubectl describe pods/my-pod

    Exemple de résultat :

    [oracle@ocne ~]$ kubectl describe pods/my-pod
Name:             my-pod
Namespace:        default
Priority:         0
Service Account:  default
Node:             ocne-worker-1/192.168.122.122
Start Time:       Wed, 06 Aug 2025 15:09:55 +0000
Labels:           <none>
Annotations:      <none>
Status:           Running
IP:               10.244.1.6
IPs:
  IP:  10.244.1.6
Containers:
  test-container:
    Container ID:   cri-o://c2ea59274a702f9cdb044d92869b63da27249370a0c55bef2994f49a092e527a
    Image:          ghcr.io/oracle/oraclelinux9-nginx:1.20
    Image ID:       ghcr.io/oracle/oraclelinux9-nginx@sha256:16b15a609a172059f9e66ae412dde3b9febe0b0fdd4eb1084eac2783088de6f1
    Port:           8080/TCP
    Host Port:      0/TCP
    State:          Running
...
...
...
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  48m   default-scheduler  Successfully assigned default/my-pod to ocne-worker-1
  Normal  Pulling    48m   kubelet            Pulling image "ghcr.io/oracle/oraclelinux9-nginx:1.20"
  Normal  Pulled     48m   kubelet            Successfully pulled image "ghcr.io/oracle/oraclelinux9-nginx:1.20" in 10.66s (10.66s including waiting). Image size: 267010601 bytes.
  Normal  Created    48m   kubelet            Created container: test-container
  Normal  Started    48m   kubelet            Started container test-container

    Cela confirme que la commande podman kube play a utilisé le fichier YAML Kubernetes pour déployer un pod directement vers un cluster Kubernetes.

Déployer le YAML Kubernetes généré par Podman sur un cluster Kubernetes

Déployez le fichier YAML Kubernetes généré par Podman que vous avez créé au début du tutoriel sur un cluster Kubernetes.

  1. Déployez le fichier nginx-pod.yaml sur le cluster Kubernetes.

    podman kube apply -f nginx-pod.yaml

    Exemple de résultat :

    [oracle@ocne ~]$ podman kube apply -f nginx-pod.yaml
Deploying to cluster...
Successfully deployed workloads to cluster!

  2. Vérifiez que le pod est déployé sur votre cluster.

    kubectl get pods

    Exemple de résultat :

    [oracle@ocne ~]$ kubectl get pods
NAME       READY   STATUS    RESTARTS   AGE
my-nginx   1/1     Running   0          1m59s
my-pod     1/1     Running   0          5m12s

  3. Vérifiez que Nginx est déployé comme prévu.

    kubectl describe pods/my-nginx

    Cela confirme que Podman a déployé un YAML Kubernetes généré par podman appelé 'my-nginx' vers le cluster Kubernetes.

Etapes suivantes

Ce tutoriel a démontré comment utiliser Podman pour déployer des charges de travail Kubernetes vers un cluster Kubernetes avec Oracle Cloud Native Environment. Consultez le module de formation Oracle Linux pour obtenir des tutoriels et du contenu supplémentaires.

Ressources de formation supplémentaires

Explorez d'autres ateliers sur le site docs.oracle.com/learn ou accédez à d'autres contenus d'apprentissage gratuits sur le canal Oracle Learning YouTube. En outre, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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