# Tutorial de Docker: introducción a la popular plataforma de contenedores

En nuestro tutorial de Docker, explicamos la plataforma de virtualización [Docker](https://www.ionos.mx/digitalguide/servidores/know-how/que-es-docker/) y te brindamos instrucciones fáciles de seguir sobre cómo utilizarla en tu sistema [Ubuntu](https://www.ionos.mx/digitalguide/servidores/know-how/ubuntu-un-sistema-para-todos-basado-en-linux/) 22.04.

## Docker: estructura y funciones

Con el eslogan “Build, Ship and Run Any App, Anywhere” la plataforma de contenedores de código abierto Docker promociona una alternativa flexible y eficiente a la emulación de componentes de hardware basada en máquinas virtuales (VM).

A diferencia de la **virtualización tradicional de hardware**, que implica iniciar diferentes sistemas huésped en un mismo sistema anfitrión (host), Docker permite que las aplicaciones se ejecuten como procesos aislados dentro del mismo sistema gracias a los **contenedores**. Por lo tanto, en la [virtualización de servidores basada en contenedores](https://www.ionos.mx/digitalguide/servidores/know-how/docker-container-las-ventajas-de-los-contenedores-web/), se logra una **virtualización a nivel del sistema operativo**.

[![Imagen: Comparación entre máquinas virtuales y contenedores de Docker](https://www.ionos.mx/digitalguide/fileadmin/_processed_/4/6/csm_maquinas-virtuales-vs-contenedores-docker_2c68ee2c14.webp "Comparación entre máquinas virtuales y contenedores de Docker")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Schaubilder/maquinas-virtuales-vs-contenedores-docker.png) Mientras que cada máquina virtual inicia su propio sistema operativo, los contenedores de Docker comparten el núcleo (kernel La principal ventaja de la virtualización basada en contenedores radica en que las aplicaciones con diferentes requisitos pueden ejecutarse de forma aislada sin la sobrecarga de sistemas huésped separados. Además, las aplicaciones en contenedores se pueden utilizar de manera **multiplataforma y en diversas infraestructuras**, sin necesidad de adaptarlas a las configuraciones de hardware o software del sistema host.

Docker es el proyecto de software más conocido de los que ofrecen **tecnología de virtualización basada en contenedores**. La plataforma de código abierto consta de tres componentes principales: el **motor Docker** (Docker engine), las **imágenes Docker** y el repositorio **Docker Hub**.

Consejo Los contenedores e imágenes Docker suelen ser genéricos, pero también pueden personalizarse si es necesario. Puedes obtener más información al respecto en nuestro artículo sobre [contenedores Docker](https://www.ionos.mx/digitalguide/servidores/know-how/docker-container/).

### Docker Images

De forma similar a las máquinas virtuales, los contenedores de Docker se basan en [imágenes Docker](https://www.ionos.mx/digitalguide/servidores/know-how/docker-image/), que son plantillas de solo lectura con todas las instrucciones necesarias para que el motor Docker cree un contenedor. Una imagen Docker es una **representación portátil de un contenedor**, presentada en forma de archivo de texto, es decir, un [Dockerfile](https://www.ionos.mx/digitalguide/servidores/know-how/dockerfile/). Antes de iniciar un contenedor en un sistema, se carga un paquete con la imagen correspondiente, a menos que ya esté almacenada localmente. La imagen cargada contiene todos los **sistemas de archivos con los parámetros** necesarios para la ejecución. Un contenedor es esencialmente un proceso en ejecución de una imagen.

### Docker Hub

El Docker Hub es un **registro para repositorios de software** en la nube, es decir, actúa como una especie de biblioteca para las imágenes Docker. Es un servicio en línea que contiene repositorios públicos y privados. Los repositorios públicos permiten a los usuarios subir sus propias imágenes y compartirlas con la comunidad. Aquí se encuentran numerosas imágenes Docker oficiales realizadas por el equipo de desarrolladores, así como proyectos de código abierto consolidados. Por el contrario, no todo el mundo tiene acceso a las imágenes de los repositorios privados, aunque sí se pueden compartir dentro de la misma empresa o en un determinado grupo. Al repositorio de Docker Hub se accede a través de [*hub.docker.com*](https://hub.docker.com/ "Página web de Docker Hub").

### Motor Docker

El corazón de cualquier proyecto Docker es su motor, una aplicación **cliente-servidor de código abierto** disponible en todas las plataformas establecidas en la versión actual.

La arquitectura básica del motor Docker consta de tres componentes principales: un **Docker daemon**, que funciona como servidor, una **interfaz de programación (API)** basada en REST (Representational State Transfer) y la **terminal del sistema operativo** (Command-Line Interface, CLI) como interfaz de usuario (client).

- **Docker daemon**: el motor Docker utiliza un proceso daemon como servidor, que se ejecuta en segundo plano en el sistema host y permite el control central del motor. Además, se encarga de crear y administrar imágenes, contenedores o redes.
- **La API REST**: especifica un conjunto de interfaces que permite a otros programas interactuar y dar instrucciones al daemon . Uno de los cuales es la terminal del sistema operativo.
- **La terminal**: Docker utiliza la terminal del sistema operativo como programa cliente, la cual interacciona con el daemon a través de la API REST y permite a los usuarios controlar el daemon a través de scripts o comandos.

Consejo En 2017, el motor Docker fue renombrado como *Docker Community Edition* (abreviado como Docker CE), aunque la documentación oficial y los repositorios de Docker siguen usando en su mayoría el nombre antiguo. Además de Docker CE, también existe el *Docker Enterprise Edition* (Docker EE), que ofrece algunas características premium. Sin embargo, Docker EE no es gratuito y se orienta más hacia las empresas.

Con los [comandos de Docker](https://www.ionos.mx/digitalguide/servidores/know-how/comandos-de-docker/), los usuarios pueden ejecutar, detener o gestionar los contenedores de software directamente desde la terminal. Utilizando el comando `docker` junto con instrucciones como `build` (crear), `pull` (descargar) o `run` (ejecutar), es posible comunicarse con el daemon, permitiendo que el cliente y el servidor estén en el mismo sistema. Además, también es posible comunicarse con el daemon desde otro sistema. La comunicación entre el cliente y el servidor puede realizarse a través de la API REST, sockets UNIX o una interfaz de red, según el tipo de conexión requerida.

La siguiente imagen muestra cómo se combinan los **componentes individuales de Docker**, utilizando los comandos `docker build`, `docker pull` y `docker run` como ejemplos:

[![Imagen: Presentación esquemática de la arquitectura Docker](https://www.ionos.mx/digitalguide/fileadmin/_processed_/8/4/csm_diagrama-arquitectura-docker_3a86a554bb.webp "Presentación esquemática de la arquitectura Docker")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Schaubilder/diagrama-arquitectura-docker.png) La arquitectura Docker se basa en la combinación de cliente (terminal El comando `docker build` da instrucciones al daemon para crear una imagen (línea punteada), utilizando el **Dockerfile** correspondiente. El comando `docker pull` (línea discontinua) se ejecuta cuando el usuario no ha creado la imagen, sino que la obtiene de un repositorio en Docker Hub. Si se ordena al daemon iniciar un contenedor con el comando `docker run`, primero verifica si la imagen que se necesita está almacenada de forma local. Si es así, el contenedor se inicia (línea continua). En caso contrario, el daemon obtiene la imagen directamente del repositorio.

## Trabajar con Docker

Ha llegado el momento de familiarizarse con las **posibilidades de aplicación de la plataforma de contenedores**. Si aún no has instalado el motor Docker, puedes hacerlo a través de la terminal de Linux. Puedes encontrar instrucciones sobre cómo hacerlo en nuestro artículo “[instalar Docker en Ubuntu 22.04](https://www.ionos.mx/digitalguide/servidores/configuracion/docker-ubuntu-2204/)”. A continuación, aprenderás a manejar el motor Docker desde la consola, conocerás las capacidades de Docker Hub y comprenderás por qué los contendores representan una revolución en la gestión de aplicaciones.

Consejo Si quieres instalar Docker en otra distribución de Linux o en Windows, las siguientes guías te serán de gran ayuda:

- [Cómo instalar Docker en Debian 11](https://www.ionos.mx/digitalguide/servidores/configuracion/instalar-docker-en-debian-11/)
- [Cómo instalar Docker en Ubuntu 20.04](https://www.ionos.mx/digitalguide/servidores/configuracion/docker-ubuntu-2004/)
- Cómo instalar Docker en CentOS 7
- [Cómo instalar Docker en Windows 10](https://www.ionos.mx/digitalguide/servidores/configuracion/instalar-docker-en-windows-10/)
- [Cómo instalar Docker en Windows 11](https://www.ionos.mx/digitalguide/servidores/configuracion/instalar-docker-en-windows-11/)
- [Cómo instalar Docker en Raspberry Pi](https://www.ionos.mx/digitalguide/servidores/configuracion/docker-y-raspberry-pi/)

### Cómo manejar el motor Docker

Desde la versión 16.04, Ubuntu utiliza el **programa *systemd***(abreviatura de “system aemon”) para gestionar procesos.*systemd*es un proceso init que también puede utilizarse en otras distribuciones de Linux como RHEL, CentOS o Fedora, y generalmente se identifica con el ID de proceso 1. Como primer proceso del sistema, el daemon es responsable de iniciar, detener y hacer el seguimiento del resto de procesos. En versiones previas de Ubuntu (14.10 y anteriores), el programa*upstart* se encargaba de dichas funciones.

También se puede controlar al Docker daemon a través de *systemd*. En la instalación estándar, la plataforma de contenedores está configurada para que el daemon se inicie automáticamente al arrancar el sistema. No obstante, el ajuste predeterminado se puede cambiar utilizando la herramienta ***systemctl*** de línea de comandos.

Con el objetivo de controlar un proceso o conocer su estado, puedes mandar órdenes a *systemd* mediante *systemctl*. La sintaxis de dicho comando es la siguiente:

```bash
systemctl [OPCIÓN] [COMANDO]
```

Algunos comandos hacen referencia a determinados recursos, como Docker. La terminología de *systemd* se refiere a los recursos como units (unidades). En cuyo caso, el comando deriva de las instrucciones correspondientes y del nombre de la unidad a la que se dirige.

Si quieres activar (*enable*) o desactivar (*disable*) el **inicio automático del Docker daemon**, utiliza la herramienta *systemctl* con los siguientes comandos:

```bash
sudo systemctl enable docker
sudo systemctl disable docker
```

*systemctl* también permite consultar el **estado de una unidad**:

```bash
sudo systemctl status docker
```

Si el motor Docker está activo en el sistema Ubuntu, la salida en la terminal debería ser la siguiente:

[![Imagen: La consulta de estado con systemctl muestra que el motor Docker está activo (running)](https://www.ionos.mx/digitalguide/fileadmin/_processed_/f/7/csm_docker-status-active-running_f52601bd11.webp "La consulta de estado con systemctl muestra que el motor Docker está activo (running)")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-status-active-running.png) Consulta de estado con systemctl: el motor Docker está activo (running) Si el motor Docker se encuentra desactivado, te aparecerá el estado como inactivo (*dead*) por lo que será necesario iniciar Docker daemon de forma manual para ejecutar los contenedores.

[![Imagen: La consulta de estado con systemctl muestra: el motor Docker está inactivo (dead)](https://www.ionos.mx/digitalguide/fileadmin/_processed_/d/a/csm_docker-status-inactive_cad5668ee9.webp "La consulta de estado con systemctl muestra: el motor Docker está inactivo (dead)")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-status-inactive.png) Consulta de estado con systemctl: el motor Docker está inactivo (dead) Si quieres **iniciar, detener o reiniciar el motor Docker de forma manual**, dirígete a *systemd* con uno de los siguientes comandos:

Para **iniciar el daemon desactivado** utiliza *systemctl* junto con el comando `start`:

```bash
sudo systemctl start docker
```

Si lo que quieres es **detener el Docker daemon**, utiliza el comando `stop`:

```bash
sudo systemctl stop docker
```

Para **reiniciar el motor**, utiliza `restart`:

```bash
sudo systemctl restart docker
```

### Cómo usar Docker Hub

Si el motor Docker representa el corazón de la plataforma de contenedores, Docker Hub es el alma del proyecto de código abierto, ya que aquí es donde la comunidad se reúne. Los usuarios encuentran en el **registro en la nube** todo lo que necesitan para dar vida a la instalación de Docker.

El servicio en línea ofrece **diversos repositorios oficiales con más de 100 000 aplicaciones gratuitas**. Los usuarios también tienen la posibilidad de crear sus propias imágenes y compartirlas con grupos de trabajo. Además del soporte profesional que ofrece el equipo de desarrolladores, aquí también es posible conectarse con la comunidad de usuarios. En [GitHub](https://github.com/docker/hub-feedback/issues "Página de Github sobre Docker"), los usuarios tienen acceso a un foro de soporte.

[![Imagen: Docker Hub: apartado de registro](https://www.ionos.mx/digitalguide/fileadmin/_processed_/a/0/csm_docker-hub-login-page_d232488fe7.webp "Docker Hub: apartado de registro")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-login-page.png) El Docker ID personal se crea de forma gratuita en el apartado del registro / Fuente: hub.docker.com #### Registrarse en Docker Hub

**Registrarse en Docker Hub es gratis** y solo requiere una dirección de correo electrónico y un Docker ID propio, que luego se utilizará como **nombre de espacio personal para el repositorio** y permite acceder a todos los servicios de Docker. La oferta incluye Docker Hub, Docker Cloud, Docker Store y algunos programas Beta. Además, con el **Docker ID**, se obtiene acceso al centro de asistencia de Docker, así como al Docker Success Portal y a los [foros de Docker](https://www.docker.com/docker-community "Foros de la comunidad Docker").

Puedes registrarte siguiendo estos cinco pasos:

1. **Elige un Docker ID:** en el registro debes elegir un nombre de usuario que más tarde va a convertirse en tu ID.
2. **Escribe tu dirección de correo electrónico:** introduce una dirección de correo electrónico activa, ya que servirá para confirmar la inscripción en Docker Hub.
3. **Crea una contraseña:** elige una contraseña.
4. **Envía la inscripción:** haz clic sobre “Sign up” para confirmar tu inscripción. Si todos los datos se han completado correctamente, se envía un enlace de verificación a la dirección proporcionada.
5. **Confirma tu dirección de correo electrónico:** confirma tu cuenta de correo haciendo clic en el enlace de verificación.

Después de registrarte, podrás acceder directamente a los servicios en línea del proyecto de Docker desde el navegador. Aquí puedes crear repositorios y grupos de trabajo, así como buscar recursos de acceso público a través de la función “Explore”.

[![Imagen: Panel de control de Docker Hub](https://www.ionos.mx/digitalguide/fileadmin/_processed_/f/a/csm_docker-hub-dashboard_1d08a8d15d.webp "Panel de control de Docker Hub")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-dashboard.png) En el panel de control de Docker Hub puedes administrar los repositorios y grupos de trabajo / Fuente: hub.docker.com También puedes registrarte directamente desde la consola del sistema operativo utilizando el comando `docker login`. Puedes encontrar una explicación detallada del comando en la [documentación de Docker](https://docs.docker.com/engine/reference/commandline/login/ "Documentación detallada sobre Docker").

En principio, los usuarios **sin una cuenta ni Docker ID** también pueden acceder a Docker Hub, aunque solo podrán descargar imágenes de los repositorios de acceso público y tienen vetado cargar (*push*) sus imágenes propias.

#### Crear repositorios en Docker Hub

La **cuenta gratuita en Docker Hub** incluye un repositorio de acceso privado y permite crear tantos repositorios de acceso público como quieras. No obstante, puedes desbloquear más repositorios de acceso privado con una **actualización de pago**.

Para crear un repositorio, sigue los siguientes pasos:

1. **Elige un espacio de nombres:** cuando creas un repositorio, se le asigna automáticamente el espacio de nombres de tu Docker ID, aunque también se le puede asignar el de una organización a la que pertenezcas.
2. **Dale un nombre al repositorio:** asigna un nombre al repositorio que estás creando.
3. **Añade una descripción:** añade una descripción al repositorio.
4. **Configura la seguridad:** decide si quieres crear un repositorio de acceso público (*public*) o uno al que solo puedas acceder tú o tu organización (*private*).

Haz clic en “Create” para confirmar la creación.

[![Imagen: Docker Hub: formulario para crear un repositorio](https://www.ionos.mx/digitalguide/fileadmin/_processed_/a/d/csm_docker-hub-repository-creation_ac7984ce9d.webp "Docker Hub: formulario para crear un repositorio")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-repository-creation.png) Tu repositorio se creará directamente en el espacio de nombres de tu Docker ID / Fuente: hub.docker.com #### Crear equipos y organizaciones

A través de Docker Hub, Docker ofrece una plataforma en la nube donde se puede **gestionar la creación de imágenes de manera centralizada** y **compartirlas fácilmente con grupos de trabajo**, a los que Docker denomina organizaciones. Al igual que con las cuentas de usuario, las organizaciones también reciben un ID individual con los que descargar imágenes o compartirlas con otros usuarios. Los roles y permisos de cada miembro se organizan en equipos. De esta forma, por ejemplo, solo los usuarios que pertenecen al grupo “Owners” pueden crear repositorios privados o públicos y asignar permisos de acceso.

También puedes crear y gestionar los grupos de trabajo a través del panel de control. Para obtener más información sobre la gestión de equipos y organizaciones, consulta la [documentación de Docker](https://docs.docker.com/docker-hub/orgs/ "Gestión de organizaciones en Docker").

### Cómo trabajar con imágenes y contenedores

Docker Hub es el punto de acceso primario para los recursos oficiales de Docker, y se convierte en el punto de partida para nuestra **introducción a la gestión de imágenes y contenedores**. Aquí, el equipo de desarrolladores presenta, entre otras, la imagen demo *whalesay*, que se utilizará como base en el tutorial de Docker que hay a continuación.

#### Descargar imágenes Docker

Para encontrar la imagen *whalesay*, accede a la página de inicio de Docker Hub e introduce el término *whalesay* en la barra de búsqueda que se encuentra a la derecha del logotipo de Docker.

[![Imagen: Función de búsqueda en Docker Hub](https://www.ionos.mx/digitalguide/fileadmin/_processed_/c/c/csm_docker-hub-whalesay-repos_eae5c60dab.webp "Función de búsqueda en Docker Hub")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-whalesay-repos.png) Busca en la barra de búsqueda de Docker Hub o con la pestaña “Explore” / Fuente: hub.docker.com En los resultados de la búsqueda, haz clic en el recurso etiquetado *docker/whalesay,* para acceder al repositorio público de esta imagen. Los repositorios Docker siempre tienen la misma estructura: en la parte superior, se muestra el título de la imagen, la categoría del repositorio y la fecha de última actualización (*last pushed*).

[![Imagen: Interfaz web de un repositorio Docker](https://www.ionos.mx/digitalguide/fileadmin/_processed_/3/e/csm_docker-hub-official-whalesay-repo_2355257104.webp "Interfaz web de un repositorio Docker")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-official-whalesay-repo.png) En los repositorios, los usuarios encuentran normalmente toda la información necesaria para la creación de imágenes / Fuente: hub.docker.com Cada repositorio Docker incluye también los siguientes apartados:

- **Description:** descripción detallada e instrucciones de uso.
- **Docker Pull Command:** consola de línea de comandos para descargar imágenes del repositorio (`pull`).
- **Owner:** información sobre el creador del repositorio.
- **Comments:** zona de comentarios al final de la página.

En las ventanas de información del repositorio aparece que *whalesay* es una modificación del script Perl de código abierto ***cowsay***. El programa, desarrollado por Rony Monroe en el año 1999, genera una representación gráfica ASCII de una vaca que aparece en la terminal del usuario junto con un mensaje.

Para descargar la imagen *docker/whalesay*, utiliza el comando `docker pull` con la siguiente estructura:

```bash
docker pull [OPTIONS] NAME [:TAG|@DIGEST]
```

El comando `docker pull` ordena al daemon descargar una imagen del repositorio. Para que pueda identificar la imagen, debes proporcionar su nombre (*NAME*). También puedes indicar a Docker cómo debe ejecutar el comando deseado mediante opciones (*OPTIONS*) y, de forma opcional, introducir **tags** (*:TAG*) o **números de identificación** únicos (*@DIGEST*) que permiten descargar una versión específica de una imagen.

Para crear una copia local de la imagen *docker/whalesay*, utiliza el siguiente comando:

```bash
docker pull docker/whalesay
```

Por lo general, no suele ser necesario, ya que cuando quieres iniciar un contenedor, Docker daemon descargará las imágenes automáticamente del repositorio si no las encuentra en el sistema local.

#### Iniciar imágenes de Docker como contenedores

Para iniciar una imagen de Docker, utiliza el comando `docker run` con la siguiente estructura base:

```bash
docker run [OPTIONS] IMAGE [:TAG|@DIGEST] [CMD] [ARG…]
```

La única parte obligatoria del comando `docker run` es el nombre de la imagen de Docker que quieres iniciar. Sin embargo, al iniciar un contenedor, también puedes especificar otras opciones, TAGs y DIGEST. Además, puedes combinar el comando `docker run` con otros comandos que se ejecutan al iniciar el contenedor. En este caso, se sobrescribe el comando **CMD** (COMMAND) establecido por el creador, que se ejecuta automáticamente al iniciar el contenedor. Con **argumentos adicionales** (*ARG…*), puedes definir otras configuraciones opcionales, como agregar usuarios o transferir variables de entorno (*environment variables*).

Utiliza el siguiente comando:

```bash
docker run docker/whalesay cowsay boo
```

para descargar el script correspondiente de Perl como imagen y ejecutarlo en un contendor. Verás que *whalesay* se diferencia mucho del script original.

[![Imagen: Salida en la terminal del contenedor docker/whalesay: la ballena dice “boo”](https://www.ionos.mx/digitalguide/fileadmin/_processed_/e/4/csm_docker-run-whalesay-boo-english_82f28f20b7.webp "Salida en la terminal del contenedor docker/whalesay: la ballena dice “boo”")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-run-whalesay-boo-english.png) Si se ejecuta “docker/whalesay” con el comando estándar, la ballena de Docker se limita a un breve “boo” Al ejecutar la imagen *docker/whalesay*, el script muestra en la consola una gráfica ASCII en forma de ballena, así como el mensaje “boo” que genera el comando *cowsay*.

Similar a la prueba anterior, el daemon buscará primero la imagen en el directorio local de archivos. Si no encuentra un paquete con el mismo nombre, inicia una descarga desde el repositorio de Docker mediante un comando pull. Finalmente, el daemon iniciará el programa modificado de cowsay. Una vez finalizado, el **contenedor se cerrará automáticamente**.

Al igual que con *cowsay*, *whalesay* de Docker también permite intervenir en la salida de texto en la terminal. Prueba la función sustituyendo el mensaje “boo” en el comando de salida con otra cadena de caracteres, como un chiste de ballenas.

```bash
sudo docker run docker/whalesay cowsay What did the shark say to the whale? What are you blubbering about?
```

[![Imagen: Salida en la terminal del contenedor docker/whalesay: la ballena muestra un mensaje de texto personalizado](https://www.ionos.mx/digitalguide/fileadmin/_processed_/8/6/csm_docker-run-whalesay-joke_6337d3f36a.webp "Salida en la terminal del contenedor docker/whalesay: la ballena muestra un mensaje de texto personalizado")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-run-whalesay-joke.png) La ballena puede mostrar mensajes de texto personalizados #### Visualizar todas las imágenes Docker en el sistema local

Para comprobar si has descargado una imagen específica, puedes acceder a una **vista general de todas las imágenes en tu sistema local** utilizando el siguiente comando:

```bash
sudo docker images
```

El comando `docker images` (o alternativamente `docker image ls`) te muestra todas las imágenes locales junto con información sobre el tamaño del archivo, el tag y el ID de cada imagen.

[![Imagen: Listado de todas las imágenes en el sistema local](https://www.ionos.mx/digitalguide/fileadmin/_processed_/3/9/csm_sudo-docker-images-empty_9806635619.webp "Listado de todas las imágenes en el sistema local")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-images-empty.png) La lista de imágenes descargadas muestra “hello-world” y “docker/whalesay” Al iniciar un contenedor, la imagen subyacente se descarga del repositorio como una copia y se guarda permanentemente en tu ordenador, lo que te permite ahorrar tiempo en futuros accesos. Solo necesitarás una nueva descarga si cambia la fuente de la imagen, como ocurre cuando hay una versión actualizada disponible en el repositorio.

#### Visualizar todos los contenedores en el sistema local

Si quieres **visualizar todos los contenedores** que se están ejecutando o han sido ejecutados en el sistema, debes usar el comando `ocker ps` junto con la opción `--all` (abreviado como: `-a`):

```bash
sudo docker ps -a
```

[![Imagen: Vista general de todos los contenedores en el sistema local](https://www.ionos.mx/digitalguide/fileadmin/_processed_/5/a/csm_sudo-docker-ps-a-english_74f680383e.webp "Vista general de todos los contenedores en el sistema local")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-ps-a-english.png) La vista general muestra todos los contenedores iniciados en el motor Docker La información obtenida en la terminal incluye el **ID del contendor** correspondiente, la **imagen** subyacente, el **comando** ejecutado para su inicio, la **hora de inicio** y su **estado** actual.

Si quieres ver solo los contendores que están actualmente en ejecución, utiliza el comando `docker ps` sin ninguna opción:

```bash
sudo docker ps
```

No obstante, ahora no deberías tener ningún contenedor ejecutándose en tu sistema.

#### Crear imágenes Docker

Ya sabes cómo encontrar imágenes en Docker Hub, descargarlas y ejecutarlas en cualquiera de los sistemas en los que esté instalado el motor Docker. Sin embargo, Docker no se limita únicamente a proporcionarte una amplia gama de aplicaciones en su repositorio; también te brinda un gran abanico de recursos para **crear tus propias imágenes** y compartirlas con otros desarrolladores.

En los capítulos introductorios de este artículo, hemos visto que cada imagen de Docker se construye sobre un **Dockerfile**, el cual funciona como un conjunto de **instrucciones de montaje para imágenes**. Dockerfile es un archivo de texto sencillo que contiene todas las instrucciones que Docker necesita para crear una imagen. En los siguientes apartados te explicaremos cómo escribir un Dockerfile y cómo indicar a Docker que lo utilice como punto de partida para crear tu propia imagen.

1. **Crea un nuevo directorio:** el equipo de desarrolladores de Docker recomienda crear un directorio propio para cada Dockerfile, un proceso sencillo de realizar en la terminal de Linux. Utiliza el siguiente comando para crear un nuevo directorio con el nombre *mydockerbuild*:

```bash
mkdir mydockerbuild
```

[![Imagen: Terminal Ubuntu: el comando mkdir](https://www.ionos.mx/digitalguide/fileadmin/_processed_/4/8/csm_mkdir-mydockerbuild-english_b8f27a8820.webp "Terminal Ubuntu: el comando mkdir")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/mkdir-mydockerbuild-english.png) Crear nuevos directorios con el comando “mkdir” 2. **Accede al nuevo directorio:** para ello usa el comando `cd`.

```bash
cd mydockerbuild
```

[![Imagen: Terminal Ubuntu: el comando cd](https://www.ionos.mx/digitalguide/fileadmin/_processed_/6/d/csm_cd-mydockerbuild-english_93ecadd291.webp "Terminal Ubuntu: el comando cd")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/cd-mydockerbuild-english.png) El comando “cd” te permite acceder a otro directorio de trabajo 3. **Crea un nuevo archivo de texto:** los editores de texto como Nano y [Vim](https://www.ionos.mx/digitalguide/servidores/herramientas/editores-linux-como-editar-codigo-con-vim/) te permiten crear archivos de texto desde la terminal de Ubuntu. Crea un archivo de texto con el nombre *Dockerfile* en tu directorio *mydockerbuild*.

```bash
nano Dockerfile
```

[![Imagen: Terminal Ubuntu: crear archivos de texto con Nano](https://www.ionos.mx/digitalguide/fileadmin/_processed_/2/4/csm_nano-dockerfile-empty_b2b1b6195b.webp "Terminal Ubuntu: crear archivos de texto con Nano")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/nano-dockerfile-empty.png) Nano es un editor de texto que viene preinstalado en todas las versiones de Ubuntu 4. **Escribe el Dockerfile:** el archivo de texto que acabas de crear va a contener las instrucciones necesarias para crear tu nueva imagen. En vez de programar la imagen desde cero, en este tutorial de Docker vamos a utilizar el comando *FROM* para utilizar la imagen *docker/whalesay* como plantilla para tu nueva imagen. Utiliza *:latest* como tag para indicar que debe coger la versión más actualizada de la imagen.

```none
FROM docker/whalesay:latest
```

Hasta este momento, la funcionalidad de *docker/whalesay* se centra en permitir que el usuario elija las palabras que salen de la boca de la ballena, de modo que en la terminal aparezca exactamente ese texto junto al comando de inicio del contenedor. Sería mucho más interesante si el script generase **automáticamente** nuevas salidas de texto, lo cual es posible, gracias a programas como *fortunes*, que está disponible para el sistema Linux, y cuya función principal consiste en generar proverbios y aforismos entretenidos. Puedes actualizar el índice de paquetes locales e instalar *fortunes* con el siguiente comando:

```none
RUN apt-get -y update && apt-get install -y fortunes
```

Finalmente, define una sentencia *CMD* que se ejecutará después del comando RUN, siempre y cuando no se haya reescrito con (`docker run image CMD`). Utiliza el siguiente comando para ejecutar el programa *fortunes* con la opción `-a` (“Elegir entre todas las bases de datos”) y mostrar la salida a través del programa *cowsay* en el terminal:

```none
CMD /usr/games/fortune -a | cowsay
```

En este momento, el dockerfile debería tener el siguiente contenido:

```none
FROM docker/whalesay:latest
RUN apt-get -y update && apt-get install -y fortunes
CMD /usr/games/fortune -a | cowsay
```

Ten en cuenta lo siguiente: los **comandos** de un Dockerfile están limitados a **una sola línea** y siempre empiezan con una palabra clave. La sintaxis no distingue entre mayúsculas o minúsculas, aunque se ha establecido que las palabras clave deben ir escritas en mayúsculas.

[![Imagen: El editor de texto Nano en la terminal de Ubuntu](https://www.ionos.mx/digitalguide/fileadmin/_processed_/b/b/csm_nano-dockerfile-full_bd1796f06d.webp "El editor de texto Nano en la terminal de Ubuntu")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/nano-dockerfile-full.png) Puedes controlar el editor de texto Nano con la combinación de teclas que aparecen en la zona inferior de la ventana 5. **Guarda y cierra el archivo de texto:** guarda tus entradas. Si utilizas el editor Nano, presiona la combinación de teclas \[Ctrl\] + \[O\] y confirma con \[Enter\] para guardar. Nano te comunicará que se han escrito tres líneas en el archivo seleccionado. Cierra el editor de texto con la combinación de teclas \[Ctrl\] + \[X\].
6. **Crea imágenes a partir del Dockerfile:** para crear una imagen a partir de un Dockerfile, dirígete primero al directorio en el que se encuentran los archivos de texto. La imagen se crea con el comando `docker build`. Si quieres asignar un nombre específico a la imagen de forma individual o proporcionarle un tag, utiliza la opción `-t` junto con la combinación del nombre elegido y el tag. El formato estándar es `name:tag`.

En el siguiente ejemplo se crea una imagen con el nombre *docker-whale*:

```bash
docker build -t docker-whale .
```

El signo ortográfico del **punto** indica que el Dockerfile se encuentra en el directorio actual, aunque también tienes la posibilidad de añadir una ruta de archivos o un URL a los archivos original.

El proceso *build* comienza tan pronto como se haya confirmado el comando con \[Enter\]. Primero el Docker daemon comprueba si dispones de todos los archivos necesarios para crear una imagen, a los que se conoce como “Context” de acuerdo con la terminología de Docker. Luego, se ubica la imagen *docker/whalesay* con el Tag *:latest*. Si el Context necesario para la imagen está completo, el Docker daemon iniciará la plantilla incorporada de la imagen utilizando la instrucción *FROM* en un contenedor temporal y luego procederá con los siguientes comandos del *Dockerfile*. En este caso, el siguiente comando es un *RUN* que instala el programa *fortunes*.

Al finalizar cada paso en el proceso de creación de la imagen, Docker asigna un **ID a la capa** (layer) **creada** en ese paso. Es importante tener en cuenta que cada línea del Dockerfile se traduce en una capa de la imagen construida.

Cuando finaliza el comando *RUN*, el Docker daemon detiene el contenedor temporal que se utilizó para este propósito, lo elimina e inicia un nuevo contenedor temporal para la capa de la sentencia CMD. Una vez finalizado el proceso de construcción, el contenedor temporal se cerrará y eliminará. Docker mostrará el ID de la nueva imagen, tal que así:

```none
Successfully built a8f2048c9ab8
```

[![Imagen: Terminal Ubuntu: notificaciones de estado durante la creación de la imagen](https://www.ionos.mx/digitalguide/fileadmin/_processed_/f/6/csm_sudo-docker-build-whale-english_d6b1eb3cf7.webp "Terminal Ubuntu: notificaciones de estado durante la creación de la imagen")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-build-whale-english.png) Las imágenes Docker se crean en varias capas (layers La imagen recién creada aparecerá en la lista de imágenes almacenadas localmente con el nombre de *docker-whale*.

```bash
sudo docker images
```

[![Imagen: Terminal Ubuntu: vista general de todas las imágenes](https://www.ionos.mx/digitalguide/fileadmin/_processed_/3/9/csm_docker-images-new-docker-whale_4a46337253.webp "Terminal Ubuntu: vista general de todas las imágenes")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-images-new-docker-whale.png) La imagen recién creada en el listado con todas las imágenes Para iniciar un contenedor basado en la imagen que acabas de crear, utiliza el comando `sudo docker run` seguido del nombre de tu imagen, tal que así:

```bash
sudo docker run docker-whale
```

Si la imagen se ha creado correctamente a partir del dockerfile, la ballena debería hablar elocuentemente y demostrar su sabiduría. Ten en cuenta que cada vez que inicies el contenedor, verás una frase diferente.

[![Imagen: Contenedor basado en docker-whale: salida del texto en la terminal](https://www.ionos.mx/digitalguide/fileadmin/_processed_/1/1/csm_sudo-run-docker-whale-fortunes-english_3bfb9d5385.webp "Contenedor basado en docker-whale: salida del texto en la terminal")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-run-docker-whale-fortunes-english.png) Con fortunes la ballena ASCII generará aforismos #### Hacer tagging a tus imágenes de Docker y subirlas a Docker Hub

Antes de poder subir a Docker Hub la imagen *docker-whale* que has creado y, de este modo, compartirla con la comunidad o con un grupo determinado, debes vincularla a un repositorio homónimo en tu espacio de nombres personal. El proceso de vincular se conoce como **tagging** en la terminología de Docker.

Sigue los siguientes pasos para publicar una imagen en Docker Hub:

1. **Crear un repositorio:** regístrate en Docker Hub con tu Docker ID y tu contraseña personal. Luego, crea un repositorio público y llámalo *docker-whale*.

[![Imagen: Docker Hub: formulario para la creación de un repositorio](https://www.ionos.mx/digitalguide/fileadmin/_processed_/3/3/csm_docker-hub-create-docker-whale-repo_1266f7d9ea.webp "Docker Hub: formulario para la creación de un repositorio")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-create-docker-whale-repo.png) Crea un repositorio para la imagen que has creado / Fuente: hub.docker.com 2. **Obtener el ID de la imagen:** utiliza el comando `docker images` para obtener el identificador de la imagen *docker-whale* que has creado.

[![Imagen: Vista general de todas las imágenes en la terminal de Ubuntu](https://www.ionos.mx/digitalguide/fileadmin/_processed_/5/a/csm_sudo-docker-images-id-english_265f2f9d16.webp "Vista general de todas las imágenes en la terminal de Ubuntu")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-images-id-english.png) El comando “docker images” muestra una lista de todas las imágenes guardadas en el sistema En nuestro caso, el ID de la imagen es *a8f2048c9ab8*. Necesitamos el ID para taggear (etiquetar) la imagen en el siguiente paso.

3. **Taggear la imagen:** para taggear la imagen *docker-whale*, utiliza el comando `docker tag` con el siguiente esquema:

```bash
sudo docker tag [Image-ID][Docker-ID]/[Image-Name]:[TAG]
```

En el ejemplo actual, el comando que debes introducir en la terminal para taggear es el siguiente:

```bash
sudo docker tag a8f2048c9ab8 [Namespace]/docker-whale:latest
```

Para comprobar si se ha taggeado la imagen correctamente, accede a la vista general con `docker images`. En la lista, el nombre del repositorio debería de mostrar tu Docker ID.

[![Imagen: Terminal Ubuntu: vista general de las imágenes antes y después de taggear](https://www.ionos.mx/digitalguide/fileadmin/_processed_/6/e/csm_sudo-docker-tag-docker-whale-english_d2345804e2.webp "Terminal Ubuntu: vista general de las imágenes antes y después de taggear")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-tag-docker-whale-english.png) Con “docker tag” vinculas las imágenes con tu Docker ID 4. **Subir la imagen:** primero inicia sesión en Docker Hub con el comando `docker login`:

```bash
sudo docker login
```

La terminal te pedirá tu nombre de usuario (Docker ID) y contraseña.

[![Imagen: Accede a Docker Hub a través de la terminal Ubuntu](https://www.ionos.mx/digitalguide/fileadmin/_processed_/3/3/csm_sudo-docker-login-english_77fe04ede0.webp "Accede a Docker Hub a través de la terminal Ubuntu")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-login-english.png) Debes registrarte para poder subir una imagen a Docker Hub Una vez dentro, introduce el comando `docker push` para cargar la imagen en el repositorio que creaste:

```bash
sudo docker push [Namespace]/docker-whale
```

El proceso de carga no debe de tardar más de unos segundos. La terminal te muestra el estado actual.

[![Imagen: Terminal Ubuntu: notificación de estado tras subir la imagen](https://www.ionos.mx/digitalguide/fileadmin/_processed_/c/a/csm_sudo-docker-push-whale-english_44b31ef5fd.webp "Terminal Ubuntu: notificación de estado tras subir la imagen")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-push-whale-english.png) Una vez se ha subido la imagen, se encuentra disponible en Docker Hub con el tag “latest”. Podrás ver tu imagen si entras en Docker Hub desde el navegador.

[![Imagen: Docker-Hub: repositorio [Namespace]/docker-whale en la vista detallada](https://www.ionos.mx/digitalguide/fileadmin/_processed_/5/e/csm_docker-hub-push-result_56530d8ebc.webp "Docker-Hub: repositorio [Namespace]/docker-whale en la vista detallada")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-push-result.png) En la vista detallada puedes ver la última actualización de tu repositorio / Fuente: hub.docker.com Si quieres cargar múltiples imágenes en un mismo repositorio, utiliza tags diferentes para representar las distintas versiones de las imágenes. Por ejemplo:

```none
[Namespace]/docker-whale:latest
[Namespace]/docker-whale:version1
[Namespace]/docker-whale:version2
```

En la pestaña “Tags” puedes acceder a una vista general de todas las versiones de imágenes disponibles en un repositorio.

[![Imagen: Docker Hub: pestaña “Tags”](https://www.ionos.mx/digitalguide/fileadmin/_processed_/3/9/csm_docker-hub-multiple-versions-tags_e6c43a478d.webp "Docker Hub: pestaña “Tags”")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-hub-multiple-versions-tags.png) En la pestaña “Tags” encuentras todas las versiones de una misma imagen / Fuente: hub.docker.com Por el contrario, las imágenes de proyectos diferentes deben estar ubicadas en repositorios separados.

Una vez hayas subido la imagen con éxito, estará disponible en el repositorio público para todos los usuarios del mundo.

5. **Comprobación:** verifica que la imagen se ha subido correctamente intentando descargarla.

Primero, elimina la versión local de la imagen para poder descargar una copia con el mismo tag, de lo contrario, Docker podría notificarte que la imagen que quieres ya se encuentra en su versión más actual.

[![Imagen: Estado: “Image is up to date” (“la copia local está actualizada”)](https://www.ionos.mx/digitalguide/fileadmin/_processed_/f/0/csm_sudo-docker-pull-docker-whale-english_84e2e758c4.webp "Estado: “Image is up to date” (“la copia local está actualizada”)")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-pull-docker-whale-english.png) El comando Pull se interrumpe si la imagen ya existe en local Borra las imágenes locales de Docker utilizando el comando `docker rmi` junto con el ID de la imagen, que se obtiene con `docker images`. Si se produce algún conflicto, es decir, Docker te dice que el ID de la imagen se está utilizando en más repositorios o en un contenedor, puedes **forzar la eliminación** con la opción `--force` (*abreviado*: `-f`).

```bash
sudo docker rmi -f a8f2048c9ab8
```

[![Imagen: El comando docker rmi con la opción -f (force)](https://www.ionos.mx/digitalguide/fileadmin/_processed_/b/f/csm_sudo-docker-rmi-remove-image_75b679b119.webp "El comando docker rmi con la opción -f (force)")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-rmi-remove-image.png) Utiliza el comando “docker rmi” con la opción “-f” para forzar una eliminación Vuelve a acceder a la vista general de todas las imágenes:

```bash
sudo docker Images
```

Los elementos eliminados no deberían aparecer en la salida de la terminal. Utiliza el comando Pull e indica el repositorio para descargar **una copia nueva de la imagen** desde Docker Hub:

```bash
sudo docker pull [Namespace]/€
```

[![Imagen: Terminal Ubuntu: descarga desde Docker Hub](https://www.ionos.mx/digitalguide/fileadmin/_processed_/4/8/csm_sudo-docker-pull-image-redownload_3dfb6af27f.webp "Terminal Ubuntu: descarga desde Docker Hub")](https://www.ionos.mx/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/sudo-docker-pull-image-redownload.png) La imagen que has creado previamente se ha descargado con éxito ## Más temas y tutoriales sobre Docker

El universo Docker es amplio y variado. Con el tiempo, se ha desarrollado un [ecosistema activo de herramientas relacionadas con Docker](https://www.ionos.mx/digitalguide/servidores/know-how/docker-tools-el-ecosistema-docker-de-cerca/). Docker es particularmente interesante para los administradores, especialmente cuando se utilizan aplicaciones complejas que involucran varios contenedores en diferentes sistemas paralelos. Docker ofrece varias funciones para **orquestar** un clúster de semejante naturaleza. Puedes encontrar más detalles al respecto en nuestro artículo sobre \[orquestación de contenedores Docker con Swarm y Compose Si quieres trabajar con Docker, puedes encontrar **más tutoriales** en la Digital Guide:

- [Docker container volumes](https://www.ionos.mx/digitalguide/servidores/know-how/docker-container-volumes/)
- Tutorial de Docker Compose

Docker ofrece una versatilidad excepcional en **diversos escenarios de aplicación**. En nuestra Digital Guide encontrarás los siguientes tutoriales:

- [Redis en contenedores Docker](https://www.ionos.mx/digitalguide/servidores/know-how/redis-en-docker/)
- Instalar un servidor Teamspeak con Docker

Es importante reconocer que Docker no siempre es la opción más adecuada. En nuestro análisis de [alternativas de Docker](https://www.ionos.mx/digitalguide/servidores/know-how/alternativas-a-los-contenedores-en-docker/), exploramos alternativas clave. Adicionalmente, tenemos comparaciones directas entre algunas alternativas y Docker:

- [Kubernetes vs. Docker](https://www.ionos.mx/digitalguide/servidores/know-how/kubernetes-vs-docker/)
- [Openshift vs. Docker](https://www.ionos.mx/digitalguide/servidores/know-how/openshift-vs-docker/)
- [Podman vs. Docker](https://www.ionos.mx/digitalguide/servidores/know-how/podman-vs-docker/)


This is a markdown version of: [https://www.ionos.mx/digitalguide/servidores/configuracion/tutorial-docker-instalacion-y-primeros-pasos/](https://www.ionos.mx/digitalguide/servidores/configuracion/tutorial-docker-instalacion-y-primeros-pasos/) for AI/LLM consumption.