Tema:

Publicacion de imagenes en un registry.

Introducción

En esta guía aprenderemos que es un image registry, como funciona y como subir imagenes de nuestras aplicaciones al mismo

Objetivo

Objetivo General:

El objetivo de la practica es subir imagenes de aplicativos a un image registry.

Desarrollo del Tema

Un Image Registry es un sistema de almacenamiento y distribución de imágenes de contenedor. Su función es comparable a la de un “repositorio de código” pero aplicado a imágenes: en lugar de guardar archivos de texto, guarda imágenes construidas listas para ser ejecutadas.

En un flujo de trabajo con contenedores (Docker, Podman, Kubernetes, OpenShift, etc.), el registry es un punto clave dentro del ciclo de vida de las aplicaciones.

Estructura Básica de un Registry

Registry → el servicio completo.
Ejemplo: registry.gitlab.com, quay.io, harbor.miempresa.com.
Repository → dentro del registry, cada aplicación o proyecto tiene un repositorio de imágenes.
Ejemplo: quay.io/empresa/app-backend
Tags → dentro del repositorio, cada versión de la imagen se identifica con un tag.
Ejemplo:
- app-backend:1.0
- app-backend:1.1
- app-backend:latest

El tag funciona como una etiqueta de referencia que apunta a una imagen específica. Aunque latest suele ser usado como valor por defecto, no es una versión fija y puede cambiar.

🔄 Flujo Principal: Push & Pull

Construcción
Se crea una imagen con docker build o equivalente.
Tagging

Antes de subirla, se asocia a un registry y un tag:

docker tag app-backend:1.0 quay.io/empresa/app-backend:1.0

Push

Se “empuja” la imagen al registry:

docker push quay.io/empresa/app-backend:1.0

El registry guarda las capas de la imagen y la asocia al tag indicado.
Pull
Cuando alguien quiere usar esa imagen en otra máquina o en Kubernetes:
```bash docker pull quay.io/empresa/app-backend:1.0

Importancia de los Tags

Permiten versionar imágenes como si fueran releases de software.
Evitan dependencias ambiguas: usar :1.0.0 es más predecible que :latest.
Facilitan estrategias de despliegue:
:dev → imágenes de desarrollo.
:qa → imágenes para testing.
:stable o :prod → imágenes listas para producción.

Laboratorio para el Estudiante

Acceder al laboratorio.

Ingresar al servidor de laboratorio con la llave proporcionada.
```
export LAB=X
ssh student@lab-${LAB}-aio 
```
Cambiar al usuario root
```
sudo -i
```
Instalar buildah para poder publicar las imagenes.
```
dnf -y install buildah
```

Creacion de Imagen.

Acceda a la carpeta java-demo
```
cd java-demo
```
Revise el contenido del archivo Dockerfile.jvm en la carpeta src/main/docker

Empaquete nuevamente la aplicación con el script build-package.sh desde Docker

nerdctl run -it --rm -v $PWD:/usr/src/app \
-e APP_PATH=/usr/src/app \
-e MVN_ARGS='-Dmaven.repo.local=/usr/src/app/.m2/repository -DskipTests' \
maven:3.8.5-openjdk-18 /usr/src/app/build-package.sh

Construya una imagen con el tag harbor.x-x-x-x.nip.io/apis/api-demo:1.0

buildah build -t harbor.x-x-x-x.nip.io/api-test/api-test:1.0 -f /src/main/docker/Dockerfile.jvm .

Ingresaremos a nuestra url de harbor y nos vamos a autenticar como administrador.
En la pantalla principal crearemos un nuevo proyecto con el nombre de api-test. Los demas valores los dejaremos por defecto.
Luego de esto nos iremos al menu de administration al lado izquierdo y buscaremos la parte de Users. Le daremos en New User, llenaremos los campos de la siguiente manera.
Username: pull-image
Email: example@example.com
First and last name: pull
Password: Pull1234
Confirm Password: Pull1234
Una vez creado este usuario vamos a volver al proyectod de api-test y dentro del mismo vamos a buscar la parte de Members dentro de la cual vamos a agregar nuestro nuevo usuario como un Mantainer del mismo.
Con esto tenemos nuestro proyecto en harbor y un usuario el cual puede subir imagenes al mismo. Vamos a volver a nuestra maquina virtual en la carpeta de publish-image.
Vamos a loguearnos a nuestro registry con el usuario pull generado antes.
```
buildah login --tls-verify=false harbor.x-x-x-x.nip.io
```

Vamos a pushear la imagen recien creada

buildah push --tls-verify=false harbor.x-x-x-x.nip.io/api-test/api-test:1.0

Una vez finalize el push de la imagen podemos validar en el proyecto que exista nuestra nueva imagen.

Vamos a editar el archivo dentro de src/main/resources/application.properties de la siguiente manera

# External variables
txt.msg=${TXT:null}
db.url=${DB_URL:null}

# Internal properties
quarkus.http.port=8080
quarkus.custom.welcome.message=VERSION 1.1
quarkus.java.version="OpenJDK 17"

Compilamos nuevamente el codigo

nerdctl run -it --rm -v $PWD:/usr/src/app \
-e APP_PATH=/usr/src/app \
-e MVN_ARGS='-Dmaven.repo.local=/usr/src/app/.m2/repository -DskipTests' \
maven:3.8.5-openjdk-18 /usr/src/app/build-package.sh

Vamos a crear una nueva imagen con el tag 1.1 y la vamos a subir al registry.

buildah build -t harbor.x-x-x-x.nip.io/api-test/api-test:1.1 -f /src/main/docker/Dockerfile.jvm .

buildah push --tls-verify=false harbor.x-x-x-x.nip.io/api-test/api-test:1.1

Reto!

Considere la aplicación hecha con Angular y NodeJS de la carpeta angular-demo:

Cree un Dockerfile que corresponda al servidor web que necesita la aplicación

Conclusión

En este tema, hemos aprendido a crear imagenes de contenedor y a subirlas a un image registry.