Prácticas recomendadas para crear imágenes de contenedores

Laboratorio: Prácticas recomendadas para crear imágenes de contenedores

Descripción

La presente guía describe las mejores prácticas a la hora de crear imágenes de contenedor a través de archivos Dockerfile.

Objetivo

Aplicar las prácticas recomendadas a la construcción de imágenes a través de un archivo Dockerfile

Antes de comenzar

Contar con el acceso al ambiente de laboratorio

Inicio de laboratorio

Ingresar al servidor qué contiene al ambiente de laboratorio con credenciales de administración
Crear una carpeta llamada best_practices
```
mkdir best-practices
```
```
cd best-practices
```
Crear un archivo llamado Dockerfile.multipleruns
```
vi Dockerfile.multipleruns
```

Escribir el siguiente contenido

FROM registry.suse.com/bci/bci-base:15.4

LABEL maintainer=usuario

RUN zypper -n install zip

Construya una imagen de prueba en base al Dockerfile creado

docker build -t best-practices:mruns1 -f Dockerfile.multipleruns .

Liste la información de la imagen creada y observe el apartado de Layers
```
docker image inspect best-practices:mruns1
```

Modifique el archivo Dockerfile.multipleruns agregando las siguientes líneas

RUN zypper -n install wget
RUN zypper -n install curl
RUN mkdir /tmp/tools
RUN touch /tmp/tools/single.id

Construya nuevamente la imagen de prueba

docker build -t best-practices:mruns1 -f Dockerfile.multipleruns .

Liste la información de la imagen creada y observe el apartado de Layers
```
docker image inspect best-practices:mruns1
```

Ahora cree el archivo Dockerfile.singlerun con el siguiente contenido

FROM registry.suse.com/bci/bci-base:15.4

LABEL maintainer=usuario

RUN zypper -n install zip wget curl \
    && mkdir /tmp/tools \
    && touch /tmp/tools/single.id

Construya una imagen con el tag best-practices:srun1

docker build -t best-practices:srun1 -f Dockerfile.singlerun .

Liste la información de la imagen creada y observe el apartado de Layers
```
docker image inspect best-practices:srun1
```
Modifique el archivo Dockerfile.singlerun agregando el siguiente contenido
```
COPY data.txt /data.txt
```
Cree un archivo vacío llamado data.txt
```
touch data.txt
```

Construya nuevamente la imagen pero con el tag best-practices:srun2

docker build -t best-practices:srun2 -f Dockerfile.singlerun .

Liste la información de las imágenes creadas y compare el apartado de Layers con la primera imagen

docker image inspect best-practices:srun2 best-practices:srun1 \
--format='{{println .RepoTags}}{{range .RootFS.Layers}}{{println . }}{{end}}'

Cree varios archivos y carpetas de prueba vacíos

mkdir -p bin/libs/example-1.0.0
mkdir -p node_modules/example-1.0.0
mkdir -p src/temp
touch src/temp/.env
touch src/temp/.local
mkdir .vscode

Mueva el archivo data.txt a la carpeta src
```
mv data.txt src/
```
Modifique el archivo Dockerfile.singlerun, replanzando la linea con la instruccion
```
COPY data.txt /data.txt
```
por
```
COPY src /src
```

Cree el archivo .dockerignore con el siguiente contenido

# comment
bin
node_modules
src/temp/*
.vscode

Construya una imagen con el tag best-practices:srun3 -f Dockerfile.singlerun .
```
docker build -t best-practices:srun3 -f Dockerfile.singlerun .
```
Levante un contenedor con la imagen creada y entrando a la shell
```
docker run -it --rm best-practices:srun3 bash
```
Liste los archivos que se encuentran en la carpeta src en la raiz
```
ls -la /src
```
Verifique que la carpeta temp no contenga ningún archivo
```
ls -la /src/temp
```
Salga de la shell del contenedor
```
exit
```
Modifique el archivo Dockerfile.singlerun agregando la siguiente instrucción
```
COPY node_modules /node_modules
```
Construir la imagen con el tag best-practices:srun4
```
docker build -t best-practices:srun4 -f Dockerfile.singlerun .
```
Nota: Esta acción debe fallar y generar un error que no encuentra la carpeta.
Modificar el archivo .dockerignore comentando la siguiente línea
```
#node_modules
```

Vuelva a construir la imagen

docker build -t best-practices:srun4 -f Dockerfile.singlerun .

Compruebe que los cambios fueron efectuados levantando un contenedor y entrando a la shell
```
docker run -it --rm best-practices:srun4 bash
```
```
ls -l /
ls -l /node_modules
```
Salga de la shell del contenedor
```
exit
```

Cree un nuevo archivo llamado Dockerfile.rootless con el siguiente contenido

FROM registry.suse.com/bci/bci-base:15.4

LABEL maintainer=usuario

RUN mkdir /usr/src/tools \
         && touch /usr/src/tools/.env \
         && mkdir /deployments

Cree una imagen con el tag opensuse-rootless:0.0.1-root

docker build -t opensuse-rootless:0.0.1-root -f Dockerfile.rootless .

Levante un contenedor temporal con esta imagen y entre a la shell
```
docker run -it --rm opensuse-rootless:0.0.1-root bash
```
Liste el usuario con el que se levanta el contenedor
```
whoami

cat /etc/passwd
```

Obtenga la información de los directorios creados

ls -l /usr/src
ls -l /usr/src/tools
ls -l /

exit

Modifique el archivo Dockerfile.rootless agregando las siguientes instrucciones

RUN mkdir /usr/src/tools \
         && touch /usr/src/tools/.env \
         && mkdir /deployments \
         && groupadd --sys test -g 1001 \
         && useradd --sys -u 1001 -g test test -m -d /opt/test -s /sbin/nologin
USER test

Nota: Solo debe agregar las lineas las últimas 3 lineas y modificar el salto de línea.

Cree otra imagen con el tag opensuse-rootless:0.0.1-denied

docker build -t opensuse-rootless:0.0.1-denied -f Dockerfile.rootless .

Levante un contenedor temporal con esta imagen y entre a la shell
```
docker run -it --rm opensuse-rootless:0.0.1-denied bash
```
Liste el usuario con el que se levanta el contenedor
```
whoami
cat /etc/passwd
```
Intente crear un archivo nuevo en la carpeta /usr/src/tools
```
touch /usr/src/tools/test.txt
```
Nota: Debe mostrar un error de permisos denegados.
```
exit
```

Modifique el archivo Dockerfile.rootless agregando el siguiente contenido

FROM registry.suse.com/bci/bci-base:15.4

LABEL maintainer=usuario

RUN mkdir /usr/src/tools \
         && touch /usr/src/tools/.env \
         && mkdir /deployments \
         && groupadd --sys test -g 1001 \
         && useradd --sys -u 1001 -g test test -m -d /opt/test -s /sbin/nologin \
         && chown -R test:test /usr/src/tools \
         && chown -R test:test /deployments

USER test

Nota: Solo debe agregar las lineas que contienen el comando chown y modificar el salto de línea.

Cree una nueva imagen con el tag opensuse-rootless:0.0.1-pass

docker build -t opensuse-rootless:0.0.1-pass -f Dockerfile.rootless .

Levante un contenedor temporal con esta imagen y entre a la shell
```
docker run -it --rm opensuse-rootless:0.0.1-pass bash
```
Vuelva a intentar crear un archivo en /usr/src/tools
```
touch /usr/src/tools/test.txt
```
Nota: Esta prueba debe ser satisfactoria.
```
exit
```

Limpieza de ambiente

Limpie el ambiente eliminando las imágenes creadas

docker image rm -f $(docker images --filter=label=maintainer=usuario -q)