# ¿Qué es un registro?





## Explicación

Ahora que sabes qué es una imagen de contenedor y cómo funciona, te preguntarás: ¿dónde se almacenan estas imágenes?

Bueno, puedes almacenar tus imágenes de contenedor en tu computadora, pero ¿y si quieres compartirlas con tus amigos o usarlas en otra máquina? Ahí es donde entra el registro de imágenes.

Un registro de imágenes es una ubicación centralizada para almacenar y compartir tus imágenes de contenedor. Puede ser público o privado. [Docker Hub](https://hub.docker.com) es un registro público que cualquiera puede usar y es el registro predeterminado.

Aunque Docker Hub es una opción popular, existen muchos otros registros de contenedores disponibles en la actualidad, incluidos [Amazon Elastic Container Registry (ECR)](https://aws.amazon.com/ecr/), [Azure Container Registry (ACR)](https://azure.microsoft.com/en-in/products/container-registry) y [Google Container Registry (GCR)](https://cloud.google.com/artifact-registry). Incluso puedes ejecutar tu registro privado en tu sistema local o dentro de tu organización. Por ejemplo, Harbor, JFrog Artifactory, GitLab Container Registry, etc.

### Registro frente a repositorio

Mientras trabajas con registros, es posible que escuches los términos _registro_ (registry) y _repositorio_ (repository) como si fueran intercambiables. Aunque están relacionados, no son exactamente lo mismo.

Un _registro_ es una ubicación centralizada que almacena y gestiona imágenes de contenedor, mientras que un _repositorio_ es una colección de imágenes de contenedor relacionadas dentro de un registro. Piensa en él como una carpeta donde organizas tus imágenes según los proyectos. Cada repositorio contiene una o más imágenes de contenedor.

El siguiente diagrama muestra la relación entre un registro, repositorios e imágenes.

```goat {class="text-sm"}
+---------------------------------------+
|               Registry                |
|---------------------------------------|
|                                       |
|    +-----------------------------+    |
|    |        Repository A         |    |
|    |-----------------------------|    |
|    |   Image: project-a:v1.0     |    |
|    |   Image: project-a:v2.0     |    |
|    +-----------------------------+    |
|                                       |
|    +-----------------------------+    |
|    |        Repository B         |    |
|    |-----------------------------|    |
|    |   Image: project-b:v1.0     |    |
|    |   Image: project-b:v1.1     |    |
|    |   Image: project-b:v2.0     |    |
|    +-----------------------------+    |
|                                       |
+---------------------------------------+
```

> [!TIP]
>
> Un plan Docker Personal te ofrece un repositorio privado y repositorios públicos ilimitados. Para obtener repositorios privados ilimitados, actualiza al [plan Docker Team](https://www.docker.com/pricing?ref=Docs&refAction=DocsConceptsRegistry).

## Pruébalo

En esta práctica, aprenderás a compilar y subir (push) una imagen de Docker al repositorio de Docker Hub.

### Registrarse para obtener una cuenta de Docker gratuita

1. Si aún no has creado una, dirígete a la página de [Docker Hub](https://hub.docker.com) para registrarte y obtener una nueva cuenta de Docker. Asegúrate de completar los pasos de verificación enviados a tu correo electrónico.

   ![Screenshot of the official Docker Hub page showing the Sign up page](/get-started/docker-concepts/the-basics/what-is-a-registry/images/dockerhub-signup.webp?border)

   Puedes usar tu cuenta de Google o GitHub para autenticarte.

### Crear tu primer repositorio

1. Inicia sesión en [Docker Hub](https://hub.docker.com).
2. Selecciona el botón **Create repository** en la esquina superior derecha.
3. Selecciona tu espacio de nombres (probablemente tu nombre de usuario) e ingresa `docker-quickstart` como nombre del repositorio.

   ![Screenshot of the Docker Hub page that shows how to create a public repository](/get-started/docker-concepts/the-basics/what-is-a-registry/images/create-hub-repository.webp?border)

4. Establece la visibilidad en **Public**.
5. Selecciona el botón **Create** para crear el repositorio.

Eso es todo. Has creado con éxito tu primer repositorio. 🎉

Este repositorio está vacío en este momento. Ahora solucionarás esto subiendo una imagen a él.

### Iniciar sesión con Docker Desktop

1. [Descarga e instala](https://www.docker.com/products/docker-desktop/) Docker Desktop, si aún no lo has hecho.
2. En la GUI de Docker Desktop, selecciona el botón **Sign in** en la esquina superior derecha.

### Clonar el código de muestra de Node.js

Para crear una imagen, primero necesitas un proyecto. Para comenzar rápidamente, utilizarás un proyecto de Node.js de muestra que se encuentra en [github.com/dockersamples/helloworld-demo-node](https://github.com/dockersamples/helloworld-demo-node). Este repositorio contiene un Dockerfile preconfigurado necesario para compilar una imagen de Docker.

No te preocupes por los detalles específicos del Dockerfile, ya que aprenderás sobre eso en secciones posteriores.

1. Clona el repositorio de GitHub utilizando el siguiente comando:

   ```console
   git clone https://github.com/dockersamples/helloworld-demo-node
   ```

2. Navega al directorio recién creado.

   ```console
   cd helloworld-demo-node
   ```

3. Ejecuta el siguiente comando para compilar una imagen de Docker, reemplazando `YOUR_DOCKER_USERNAME` con tu nombre de usuario.

   ```console
   docker build -t <YOUR_DOCKER_USERNAME>/docker-quickstart .
   ```

   > [!NOTE]
   >
   > Asegúrate de incluir el punto (.) al final del comando `docker build`. Esto le dice a Docker dónde encontrar el Dockerfile.

4. Ejecuta el siguiente comando para enumerar la imagen de Docker recién creada:

   ```console
   docker images
   ```

   Verás una salida como la siguiente:

   ```console
   REPOSITORY                                 TAG       IMAGE ID       CREATED         SIZE
   <YOUR_DOCKER_USERNAME>/docker-quickstart   latest    476de364f70e   2 minutes ago   170MB
   ```

5. Inicia un contenedor para probar la imagen ejecutando el siguiente comando (reemplaza el nombre de usuario con el tuyo propio):

   ```console
   docker run -d -p 8080:8080 <YOUR_DOCKER_USERNAME>/docker-quickstart
   ```

   Puedes verificar si el contenedor está funcionando visitando [http://localhost:8080](http://localhost:8080) con tu navegador.

6. Utiliza el comando [docker tag](/reference/cli/docker/image/tag/) para etiquetar la imagen de Docker. Las etiquetas de Docker te permiten etiquetar y versionar tus imágenes.

   ```console
   docker tag <YOUR_DOCKER_USERNAME>/docker-quickstart <YOUR_DOCKER_USERNAME>/docker-quickstart:1.0
   ```

7. Finalmente, es hora de subir la imagen recién compilada a tu repositorio de Docker Hub utilizando el comando [docker push](/reference/cli/docker/image/push/):

   ```console
   docker push <YOUR_DOCKER_USERNAME>/docker-quickstart:1.0
   ```

8. Abre [Docker Hub](https://hub.docker.com) y navega a tu repositorio. Ve a la sección **Tags** y observa tu imagen recién subida.

   ![Screenshot of the Docker Hub page that displays the newly added image tag](/get-started/docker-concepts/the-basics/what-is-a-registry/images/dockerhub-tags.webp?border=true)

En esta práctica, te registraste para obtener una cuenta de Docker, creaste tu primer repositorio en Docker Hub, y compilaste, etiquetaste y subiste una imagen de contenedor a tu repositorio de Docker Hub.

## Recursos adicionales

- [Guía de inicio rápido de Docker Hub](/docker-hub/quickstart/)
- [Administrar repositorios de Docker Hub](/docker-hub/repos/)

## Siguientes pasos

Ahora que comprendes los conceptos básicos de los contenedores y las imágenes, estás listo para aprender sobre Docker Compose.

[¿Qué es Docker Compose?](/get-started/docker-concepts/the-basics/what-is-a-registry/what-is-Docker-Compose)


