Revisión actual del 14:37 16 dic 2025

En esta práctica aprenderemos a utilizar podman para desplegar contenedores.

Paso 1: Instalar podman

Para instalar el paquete oficial:

apt install podman

podman es un clon de 'docker.

Si añade un usuario 'test' a su sistema con:

adduser test

recuerde hacer:

loginctl enable-linger test
systemctl start --user dbus

para evitar un warning que se muestra al ejecutar podman como usuario.

Paso 2: Repositorio de imágenes de contenedores DockerHub

Docker ofrece un servicio de nube denominado DockerHub que puede ser empleado como red social para compartir tus imágenes de Podman. En DockerHub existen además imágenes de contenedores preconfiguradas de software, muchas de ellas oficiales (ofrecidas por el propio fabricante del software) que se podrán emplear como base para construir nuevas imágenes adaptadas a nuestras necesidades.

Podremos realizar búsquedas en este repositorio DockerHub puedes emplear el siguiente comando:

podman search docker.io/library/hello-world

Para descargarnos la imagen de hello-world podemos usar la orden pull:

podman pull docker.io/library/hello-world

También podemos publicar imágenes propias, esto require registro de usuario en la nube de DockerHub, lo que no es obligatorio para la realización de esta práctica. Para subir una imagen, hay que validarse como usuario en la nube de DockerHub:

podman login docker.io

Tras introducir tu usuario y contraseña, puedes comenzar a publicar tus propias imágenes.

podman push docker.io/USUARIO/MI_IMAGEN

Este paso es opcional, sólo en caso de que se quieran subir imágenes de contenedores a la nube de docker.io.

Paso 4: Comprobar imágenes en nuestra máquina

Para ver las imágenes que tenemos en nuestra máquina, utilizaremos el comando:

podman images

Inicialmente, no tenemos imágenes en almacenamiento, podemos descargarnos la imagen oficial de Debian 13 (Trixie):

podman pull docker.io/library/debian

Ahora si, ya debería de aparecernos la imagen debian.

Comentar también que cada imagen puede tener varias etiquetas, por ejemplo, la imagen Debian 12 (Bookworm), cuando la hemos visto en el listado de imágenes, venía con el tag latest, que es el tag que se descarga por defecto, pero nosotros podemos especificar otro, por ejemplo:

podman pull docker.io/library/debian:bookworm

Para traernos la versión de la imagen de Debian 12 Bookworm.

Ahora tendremos dos imágenes con diferente etiqueta, que serían como las diferentes versiones de cada imagen.

Paso 5: Lanzar un contenedor

Un contenedor no es más que una imagen de podman ejecutándose, sería similar a una máquina virtual, aunque mucho más liviano.

Para crear un contenedor, utilizaremos una imagen, en este caso, la imagen hello-world. Hacemos lo siguiente:

podman run hello-world

Esto nos mostrará el siguiente mensaje si todo está correcto:

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Debian container with:
 $ podman run -it debian bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Al crear los contenedores utilizando el comando 'run', tenemos varias opciones:

• Lanzar una terminal en el contenedor en modo interactivo
• Lanzar en segundo plano y conectarnos posteriormente al contenedor

Paso 5.1: Lanzar una terminal en el contenedor en modo interactivo (-ti)

Para este ejemplo vamos a utilizar otra imagen diferente, en este caso vamos a utilizar una imagen de debian.

Vamos a lanzar un contenedor y ejecutar una terminal en el que se va a ejecutar el programa bash que me ofrece un interprete de órdenes:

podman run -ti debian bash

La opción -t indica que se crea un terminal en el contenedor. Y la opción -i indica que el contenedor se ejecuta en modo interactivo.

Al acceder al contenedor de debian nos aparece un hash en el prompt de la shell, que identifica a la instancia del contenedor (es valor es similar al que muestra la orden podman container ls).

Para salir del contenedor, escribimos 'exit' o pulsamos CTRL + D

Paso 5.2 Lanzar en segundo plano (-d)

Otro ejemplo, con la imagen de Debian:

podman run -dti debian

que muestra un hash que identifica de forma única el contenedor lanzado:

2ec1daae4676a4e84dc04fd91399c1dfe92119544ff12ee307991fe573d3db64

Mediante el comando attach puedo entrar al contenedor:

podman attach 2ec1daae4676

Para salir, pulsamos CTRL + P seguido de CTRL + Q.

De manera similar, puedo lanzar en segundo plano la imagen de contenedor de hello-world:

podman run -d hello-world

Y consultar los logs:

podman logs b67fae3312bc321

Paso 5.3: Añadir variables de entorno a un contenedor

Utilizaremos la imagen anterior, y vamos a añadir una variable de entorno llamada TEST que contenga el valor 'test'. A parte, también ejecutaremos la terminal como antes, para comprobar con el comando echo, que la variable de entorno está creada correctamente:

podman run -ti -e TEST=test debian bash

Ahora, desde el contenedor podemos comprobar el valor de la variable de entorno $TEST.

echo $TEST
test

Paso 6: Listar contenedores en ejecución

Hemos estado haciendo pruebas y ejecutando contenedores en el paso anterior, vamos a ver donde se encuentran estos contenedores que hemos ejecutado, y después veremos algunas opciones más del comando run.

Tenemos dos opciones para ver los contenedores:

podman container ls -a

o la versión corta:

podman ps -a

Ambas hacen lo mismo, y debería de mostrarnos una salida similar a la siguiente:

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                      PORTS               NAMES
e2bde5f5500c        debian              "bash"               6 minutes ago       Exited (0) 2 seconds ago                        pensive_sammet
544ad27dbc3c        debian              "bash"               7 minutes ago       Exited (0) 7 minutes ago                        serene_elgamal

En la información veremos que el contenedor tiene el estado exited, eso quiere decir que no se está ejecutando y ya ha finalizado. Vamos a hacer una prueba para ver un contendor ejecutándose:

podman run -d debian sleep 30

Con el comando sleep 30 esperamos 30 segundos hasta que termine el comando, asíque durante esos 30 segundos, el contenedor estará ejecutándose, veámoslo:

podman ps -a

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                      PORTS               NAMES
eacceb27d52d        debian              "sleep 30"          12 seconds ago      Up 11 seconds                                   sharp_pasteur

Vamos a ver alguna opciones más de la orden run.

Paso 6.1: Dar un nombre al contenedor (--name)

Por defecto, podman creará automáticamente un nombre como hemos visto en las salidas del comando podman ps -a. Podemos establecer el nombre del contenedor que queramos con la opción --name:

podman run -ti --name mi_debian debian

Paso 6.2: Eliminar contenedor cuando termine (--rm)

Vamos a mezclar todo lo visto anteriormente:

• Lanzar en segundo plano (-d)
• Ejecutar contenedor durante 30 segundos (sleep 30)
• Dar un nombre a la imagen (--name)
• Eliminar contenedor cuando termine (--rm)

podman run -d --rm --name bye-bye debian sleep 30

Antes y una vez pasados los 30 segundos, podemos comprobar que el contenedor ha desaparecido.

podman ps -a

Paso 7: Parar y eliminar contenedores

Para parar contenedores podemos usar el ID o su nombre:

podman stop my_container
podman stop e4901956f108
podman ps -a

Una vez hemos comprobado que han terminado su ejecución, podemos eliminar los ficheros resultantes de su ejecución:

podman container rm my_container

Para borrar todos los contenedores ya finalizados

podman container prune

Paso 8: Conectarnos a un contenedor que se está ejecutando en segundo plano

Vamos a ejecutar de nuevo un contenedor que no termine:

podman run -d -ti --name mi-contenedor debian bash

Ahora, vamos a conectarnos a este contenedor que está ejecutándose en segundo plano:

podman attach mi-contenedor

Veremos la orden bash ejecutándose, para terminar, hacemos un 'CTRL + C', y ahora, veremos que ha pasado con el contenedor:

podman ps -a

Lo veremos parado, por que lo que hemos hecho ha sido conectarnos al contenedor y parar el comando que se estaba ejecutando, así que ahora tenemos el contenedor finalizado.

Nota: Para salir del contenedor sin detenerlo hacemos 'CTRL + P' seguido 'CTRL + Q'

Paso 9: Ejecutar un comando dentro de un contenedor en ejecución

Vamos a ver otresta vez como ejecutar un comando en un contenedor que ya está ejecutándose:

podman run -d -ti --name mi-contenedor debian bash

Ahora, vamos a ejecutar un comando en ese contenedor con el nombre mi-contenedor. El comando exec es similar al comando run, pero para ejecutar un comando dentro de un contenedor:

podman exec -ti mi-contenedor ls

Para redirigir la salida a un fichero en el anfitrión:

podman exec -ti mi-contenedor ls > x.txt

Para redirigir la salida a un fichero dentro del contenedor, hacemos:

podman exec -ti mi-contenedor sh -c "ls > x.txt"

También es posible ejecutar comandos con tuberías:

podman exec -ti mi-contenedor sh -c "ls -la | grep ^d"

Paso 10: Persistencia en contenedores

Al hacer exit y salir de un contenedor, se pierden todos los cambios que hemos realizado. Los

podman run -d -ti --name mi-ejemplo debian bash

Ahora, vamos a crear una carpeta en el contenedor y comprobar que esa carpeta existe:

podman exec mi-ejemplo mkdir test
podman exec mi-ejemplo ls

Veremos que la carpeta existe, pero, ¿qué ocurre si para el contenedor?

podman container stop mi-ejemplo

Y volvemos a lanzarlo:

podman container rm mi-ejemplo
podman run -d -ti --name mi-ejemplo debian bash
podman exec mi-ejemplo ls

Podemos comprobar que la carpeta creada anteriormente, no existe.

¿Qué podemos hacer para mantener la modificaciones realizadas sobre un contenedor?

Paso 10.1: Crear una imagen derivada de la imagen base

Es posible crear una imagen derivada, con modificaciones, a partir de una imagen existente mediante la orden commit.

Por ejemplo, si queremos una imagen debian que incluya el programa ping ya instalado, tendríamos que lanzar un contenedor a partir de la imagen ubuntu:

podman run -d -ti debian bash

Suponiendo que el contenido está identificado con el ID 56ef5b312334

Instalamos el paquete ping:

podman exec 56ef5b312334 apt -y install ping

Generamos la imagen derivada con el nombre ubuntu-con-ping:

podman commit 56ef5b312334 ubuntu-con-ping

Ya podemos para nuestro contendor:

podman stop 56ef5b312334

Y lanzar un nuevo contenedor a partir de la imagen debian-con-ping:

podman run -d -ti debian-con-ping bash

Paso 10.2: Mantener la persistencia mediante volúmen

Otra opción para mantener los datos es montar un volumen al ejecutar el contenedor.

Primero crearemos una carpeta que hará de volumen en nuestra máquina, que será la que luego montemos para podman:

mkdir /home/debian/volumen

Ahora vamos a montar la carpeta al ejecutar el contenedor, lo hacemos con la opción -v, la cual tiene 3 campos separados por ':':

1. El volumen en nuestra máquina
2. Donde se montará el volumen dentro del contenedor
3. Opciones de mmontaje, por ejemplo rw (read and write) o ro (read only)

podman run --rm -ti -v /home/debian/volumen:/volumen:rw debian bash
mkdir /volumen/test
touch /volumen/test/file
exit

Una vez nos salgamos del contenedor, podemos ver que en nuestra máquina están los datos:

ls /home/ubuntu/volumen/
ls /home/ubuntu/volumen/test

La próxima vez que ejecutemos un contenedor, si montamos ese volumen, los datos estarán ahí, además esta forma tiene el beneficio de compartir datos entre nuestra máquina y el contenedor de forma sencilla.

Paso 11: Crear nuestra propia imagen de contenedor

Para crear una imagen de un contenedor con una aplicación de Python hug, creamos en primer lugar la carpeta que contendrá los ficheros que nos permiten crear la imagen.

mkdir miapp
cd miapp

Definimos un fichero Dockerfile para definir la imagen:

FROM debian

RUN apt -y update
RUN apt -y upgrade
RUN apt -y install python3-hug
RUN mkdir /app
COPY endpoint.py /app
WORKDIR /app
CMD hug -f endpoint.py

Alternativamente, puedes crear un Dockerfile empleando la imagen de Ubuntu como base en lugar de Alpine.

Y añadimos el fichero endpoint.py que emplea el framework Python hug con el contenido siguiente:

import hug

@hug.get('/welcome')
def welcome(username="unknown"):
    """ Say welcome to username """
    return "Welcome " + username

Este fichero es un ejemplo de uso de Python hug. Si hacemos una petición a /welcome?username="LSO", esto nos devolverá el mensaje "Welcome LSO".

Una vez tengamos los dos ficheros creados en nuestra máquina virtual, podemos construir nuestra imagen:

podman build -t app:v1 -f Dockerfile

Vamos a explicar para que sirve cada línea:

• FROM: servirá para basarnos en una imagen existente, en este caso, una imagen de python alpine, que contiene python y no ocupa mucho espacio
• ENV: para crear variables de entorno
• RUN: para ejecutar comandos, ya sea para crear una carpeta, instalar dependencias o cualquier otra opción que necesitemos
• COPY: para copiar datos desde nuestra máquina a la imagen
• WORKDIR: para cambiar el directorio de trabajo (lo crea si no existe)
• CMD: este comando será ejecutado por defecto al iniciar un contenedor a partir de esta imagen

Esto construirá una imagen podman basada en python:alpine, en la cual hemos guardado nuestra pequeña aplicación y se va a ejecutar cuando ejecutemos un contenedor basado en esa imagen. Para comprobar que la imagen se ha creado correctamente, listamos las imagenes, y debería de aparecernos una imagen con nombre 'app' y tag 'v1':

podman images

Ahora vamos a crear un contenedor de nuestra imagen, y vamos a añadir una nueva opción, -p 8001:8000. Esta opción hará que el puerto interno 8000 del contenedor sea expuesto en el puerto 8001 de nuestra máquina:

podman run --name my-app --rm -d -p 8001:8000 app:v1

Nota: podman supone que la redirección de puerto es TCP, para una redirección de puertos UDP, puedes usar:

... -p 8001:8000/udp

Ahora vamos a probar que funciona nuestra imagen y nuestro código. En nuestra máquina haremos:

curl -X GET http://localhost:8001/welcome?username=LSO

Comprobaremos que la salida del comando curl, es "Welcome LSO".

Antes de terminar, vamos a comprobar otro pequeño detalle que añadimos en nuestra imagen, la variable de entorno USERNAME, vamos a comprobar que funciona:

podman exec -ti my-app ash
echo $USERNAME

Funciona correctamente, pero al ejecutar el contenedor, podemos cambiar esta variable de entorno como vimos en uno de los pasos anteriores:

podman run --rm -ti -e USERNAME=me app:v1 ash
echo $USERNAME

Esto nos servirá para tener opciones por defecto y que el usuario pueda cambiarlo a su antojo, como por ejemplo contraseñas u otros detalles.

Paso 12: Eliminar imágenes

Para borrar una imagen, puede hacer:

podman image rm hello-world

Paso 13: Ejercicios

Ejercicio 1: Image derivada de Debian con el programa sl

Lance un contenedor a partir de una imagen de Debian, instale el programa sl, ejecute sl (desde fuera del contenedor) y detenga el contenedor.

Ejercicio 2

Ejercicio 3: Variante de httpd

Construya una imagen httpd-hola-mundo a partir de la imagen httpd. El fichero de index.html de la carpeta htdocs/ tiene que mostrar el mensaje "hola mundo".

podman pull httpd

Edita el fichero Dockerfile:

nano Dockerfile

Añada este contenido:

FROM httpd

COPY index.html htdocs/index.html

Edita el fichero index.html:

nano index.html

Añada este contenido:

<html>hola mundo</html>

Construye la imagen:

podman build -t mihttpd -f Dockerfile

Ahora vamos a crear un contenedor de nuestra imagen:

podman run --name mihttpd -d -p 8080:80 mihttpd

Ahora vamos a probar que funciona nuestra imagen y nuestro código:

curl -X GET http://localhost:8080

Tiene que salir por pantalla esto:

<html>hola mundo</html>

Ejercicio 4: aplicación flask

Flask es un framework python para implementar webs. Cree una imagen "miapp-flask" a partir de la imagen de "python":

• Instale flask mediante: pip install flask
• Cree la carpeta "app"
• Establezca la variable FLASK_APP a "hello.py"
• Añada el fichero "hello.py"
• Establezca el directorio de trabajo a "/app"

El fichero hello.py contiene un "hola mundo" para Flask:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

Solución con alpine:

FROM python:alpine

RUN mkdir /app
RUN pip install flask
ENV FLASK_APP="app/hello.py"
COPY hello.py
WORKDIR /
CMD flask run --host=0.0.0.0

Solución con Ubuntu:

FROM ubuntu:bionic

RUN apt-get update
RUN apt-get -y install python python-pip wget
RUN pip install Flask
ENV FLASK_APP="app/hello.py"
RUN mkdir /app
COPY hello.py /app
CMD flask run --host=0.0.0.0

Ejercicio 5: mysql

EN LA MÁQUINA VIRTUAL:

mkdir miapp
cd miapp
podman pull mysql
nano Dockerfile

FROM mysql
ENV MYSQL_ROOT_PASSWORD="lacontraseñaqueyoquiera"
RUN mkdir /app
WORKDIR /app

CTRL+O , ENTER Y CTRL+X (para guardar Dockerfile y salir)

podman build -ti mrfdocker -f Dockerfile
podman  run --name mymrf --rm -p 8001:3306 mrfdocker
docker images

EN LA TERMINAL DEL HOST:

Instalación de mysql:

apt install mysql-client-core-5.7
apt-get install mysql-server
service mysql start

Para entrar:

mysql -u root -p -P 8001

Una vez dentro de msql:

mysql> show databases;

Para salir:

exit

Ejercicio 6: python pyramid

Pyramid es un framework python para implementar webs. Cree una imagen "miapp-pyramid":

• Emplee la imagen de debian como referencia, instale los paquetes python3 y python3-pyramid.
• Cree la carpeta "app"
• Añada el fichero "hello.py"
• Establezca el directorio de trabajo a "/app"
• La aplicación se lanza con la orden: python3 hello.py
• Compruebe que funciona con curl, la ruta a la web es http://127.0.0.1:8000/hello, suponiendo que ha empleado el puerto 8000 para exponer el servicio.

El fichero hello.py contiene un "hola mundo" para Pyramid:

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    print('Request inbound!')
    return Response('Podman works with Pyramid!')

if __name__ == '__main__':
    config = Configurator()
    config.add_route('hello', '/')
    config.add_view(hello_world, route_name='hello')
    app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

Este programa recibe peticiones en el puerto 6543.

Ejercicio 7

Cree una imagen derivada de Ubuntu, instale el paquete apache2, php y libapache2-mod-php. Active el módulo de php para apache2 mediante la orden:

a2enmod php

Cree la carpeta /var/www/php.

Cree el fichero index.php

<?php 
Print "Hello, World!";
?>

y copielo a /var/www/php/.

Cree el fichero 000-default.conf y copielo a /etc/apache2/sites-enabled/

Dicho fichero contiene.

<VirtualHost *:80>
  DocumentRoot /var/www/php

  <Directory /var/www/php/>
      Options Indexes FollowSymLinks MultiViews
      AllowOverride All
      Order deny,allow
      Allow from all
  </Directory>

  ErrorLog ${APACHE_LOG_DIR}/error.log
  CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Tiene que lanzar apache con la orden: apachectl -D FOREGROUND

Tras crear la imagen, láncela mapeando el puerto 8888 al 80, pruebe que puede acceder a http://127.0.0.1:8888/php/ mediante curl

Solución:

FROM ubuntu:latest

RUN apt-get update
RUN apt-get install -y tzdata
RUN apt-get install -y apache2
RUN apt-get install -y php
RUN apt-get install -y libapache2-mod-php
RUN a2enmod php7.2
COPY index.php /var/www/php
COPY 000-default.conf /etc/apache2/sites-enabled/  
CMD apachectl -D FOREGROUND

Y para lanzarlo:

podman run --name my-app --rm -d -p 8001:8000 app:v1

y para probarlo:

curl -X GET http://127.0.0.1:8888/php/

Ejercicio 8

Instale el paquete netcat-traditional en una imagen de contenedor de ubuntu. Lance la orden:

nc -u -l -p 8080

en el contenedor. Asegúrese de crear una redirección de puertos de 9999 desde el host al puerto 8080 en el contenedor.

Desde fuera del contenedor, pruebe a conectarse con:

nc -u 127.0.0.1 9999

Ejercicio 9

Cree una imagen derivada de "ubuntu" con un Dockerfile que incluya soporte de python y lance el siguiente código en Python:

from http.server import BaseHTTPRequestHandler, HTTPServer
import time

hostName = "0.0.0.0"
serverPort = 8080

class MyServer(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header("Content-type", "text/html")
        self.end_headers()
        self.wfile.write(bytes("<html><head><title>Welcome!</title></head>", "utf-8"))
        self.wfile.write(bytes("<body>", "utf-8"))
        self.wfile.write(bytes("<p>This is an example web server.</p>", "utf-8"))
        self.wfile.write(bytes("</body></html>", "utf-8"))

if __name__ == "__main__":        
    webServer = HTTPServer((hostName, serverPort), MyServer)
    print("Server started http://%s:%s" % (hostName, serverPort))

    try:
        webServer.serve_forever()
    except KeyboardInterrupt:
        pass

    webServer.server_close()
    print("Server stopped.")

Llame a su imagen "python-http-server". Lance una instancia de la imagen "python-http-server" mapeando el puerto 9999 al puerto 8888/tcp del contenedor. Compruebe con:

curl http://127.0.0.1:9999/

que muestre la página HTML que ofrece el servidor, que debería ser:

<html><head><title>Welcome!</title></head><body><p>This is an example web server.</p></body></html>

Anexo

• Cómo usar Podman compose