Note :

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

Présentation

Podman kube fournit aux développeurs et aux administrateurs un moyen de tester les charges de travail Kubernetes à l'aide de Podman avant de les déployer dans une grappe Kubernetes. La commande podman kube est utilisée pour générer des YAML conformes à Kubernetes à partir de conteneurs Podman existants ou de pods, ou pour créer des conteneurs/modules à partir d'un fichier YAML Kubernetes. Cela offre un moyen pratique de faire facilement la transition entre les environnements Podman et Kubernetes, tirant ainsi parti du meilleur des deux écosystèmes pour réduire les cycles de développement et de test.

Note : 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. Toutefois, 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 se trouve ici.

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

Note : Ce tutoriel montre l'utilisation de Podman pour générer des fichiers YAML Kubernetes et montre ensuite comment les déployer dans une grappe Kubernetes. Toute autre gestion des objets déployés doit être effectuée à l'aide des commandes kubectl. Pour plus d'informations sur l'utilisation de kubectl, consultez la documentation en amont.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Préalables

Configurer Oracle Cloud Native Environment

Note : Si vous exécutez votre propre location, lisez les préalables du projet linux-virt-labs GitHub README.md et remplissez les conditions requises avant de déployer l'environnement de laboratoire.

  1. Ouvrez un terminal sur le Luna Desktop.

  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 collections requises.

    ansible-galaxy collection install -r requirements.yml

  5. Déployez l'environnement de l'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 de laboratoire gratuit nécessite 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 l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python, située sous les modules python3.6.

    La forme de déploiement par défaut utilise le processeur AMD et Oracle Linux 8. Pour utiliser une unité centrale 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 livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. À ce stade du livre de jeux, l'installation du CNE Oracle est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'il déploie et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Accéder à la grappe Kubernetes

  1. Ouvrez un terminal et connectez-vous au moyen de SSH à l'instance ocne.

    ssh oracle@<ip_address_of_instance>

  2. Attendez que la grappe se stabilise et que tous les pods signalent qu'ils sont en cours d'exécution.

    watch kubectl get pods -A

    Une fois que tous les pods affichent le statut STATUS En cours d'exécution, entrez 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érifiez 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 sortie :

    [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 fonction Podman Kube peut fonctionner avec des fichiers Kubernetes YAML générés par Podman ou avec des fichiers YAML Kubernetes natifs. Regardons les deux à tour de rôle.

Créer un pod Podman avec un conteneur et générer un YAML Kubernetes

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é dans une grappe Kubernetes.

  1. Créez un pod avec un serveur Nginx qui mappe le port 8081 à 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 nouveau pod appelé 'my-nginx', déploie un conteneur Nginx à l'intérieur du pod et mappe le conteneur au port 8081 sur l'hôte.

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

    podman pod ps

    Exemple de sortie :

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

  3. Confirmez 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 conforme à 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 conforme à Kubernetes, vous pouvez le déployer dans une grappe Kubernetes.

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

    cat nginx-pod.yaml

    Exemple de sortie :

    [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

Supprimer le pod et les 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 terminé 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 sortie :

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

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

Utiliser Podman Kube pour déployer YAML Kubernetes dans une grappe Kubernetes

Podman ne peut se déployer dans une grappe 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 sortie :

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

    Informations : Si kubectl est installé et qu'il y a plusieurs fichiers de configuration dans le répertoire ${HOME}/.kube, 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 sortie :

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

    Note : Exécutez toute commande kubectl avec verbosity réglée au niveau 6 ou supérieur, et la commande kubeconfig courante utilisée est incluse 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 dans votre grappe Kubernetes.

    podman kube apply -f testpod.yaml

    Exemple de sortie :

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

    Note : Elle est déployée dans l'espace de noms par défaut par défaut.

  3. Vérifiez que le pod est déployé dans votre grappe.

    kubectl get pods

    Exemple de sortie :

    [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 nommé 'my-pod' dans la grappe.

  4. Confirmez que Nginx est déployé comme prévu.

    kubectl describe pods/my-pod

    Exemple de sortie :

    [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 dans une grappe Kubernetes.

Déployer YAML Kubernetes généré par Podman dans une grappe Kubernetes

Déployez le fichier Kubernetes YAML généré par Podman que vous avez créé au début du tutoriel dans une grappe Kubernetes.

  1. Déployez le fichier nginx-pod.yaml dans votre grappe Kubernetes.

    podman kube apply -f nginx-pod.yaml

    Exemple de sortie :

    [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é dans votre grappe.

    kubectl get pods

    Exemple de sortie :

    [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. Confirmez que Nginx est déployé comme prévu.

    kubectl describe pods/my-nginx

    Cela confirme que Podman a déployé avec succès un YAML Kubernetes généré par podman appelé 'my-nginx' dans la grappe Kubernetes.

Étapes suivantes

Ce tutoriel a démontré comment utiliser Podman pour déployer des charges de travail Kubernetes dans une grappe Kubernetes avec Oracle Cloud Native Environment. Consultez la station de formation Oracle Linux pour obtenir des tutoriels et du contenu supplémentaires.

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.