Tutoriales

Cómo construir una imagen Docker personalizada usando un Dockerfile

En esta guía, presentaremos brevemente Dockerfile y cómo usar Dockerfile para automatizar el proceso Cree una imagen acoplable personalizada en linux

¿Qué es un Dockerfile?

Un Dockerfile es un archivo de texto simple que contiene instrucciones para crear una imagen acoplable. Contiene todos los comandos que el usuario puede invocar en la línea de comandos para construir la imagen.

Podemos usar dockerfile para crear nuestra propia imagen personalizada. Luego podemos compartir estas imágenes de Docker personalizadas a través de Docker Hub.

Para aquellos que se preguntan, Docker Hub es un servicio de repositorio alojado proporcionado por Docker para encontrar y compartir imágenes de contenedores con su equipo y, por supuesto, con cualquier persona en el mundo.

Imagina este escenario.si queremos usarlo antes Nginx, luego necesitamos instalar y configurar Nginx, lo que implica muchos pasos. Gracias a Dockerhub, ahora podemos descargar y ejecutar imágenes de contenedores preconstruidas de Nginx en minutos.

Imagen de Nginx Docker en Dockerhub

Para extraer la imagen de Nginx de DockerHub, ejecute:

# docker pull nginx

Una vez que hayamos extraído la imagen de la ventana acoplable, podemos usarla ejecutando la imagen con el comando:

# docker run -it -d -p 8080:8080 nginx

¡Es así de simple!

Para obtener más información sobre el uso de Docker, consulte las siguientes guías.

Hay más de 100 000 imágenes de contenedores en Dockerhub de proveedores de software, proyectos de código abierto y la comunidad.

Puede buscar y descargar cualquier imagen de contenedor de su elección desde Dockerhub y comenzar a usarla de inmediato, como se muestra arriba.

Comprender el formato Dockerfile

Docker puede leer instruir de Dockerfile.

Un Dockerfile típico contiene las siguientes instrucciones:

1. de – Establecerá la imagen base del contenedor.

ejemplo:

FROM ubuntu:22.04

Establece la imagen base del contenedor para que sea Ubuntu. Si no se especifica la etiqueta 22.04, la etiqueta se considera «más reciente».

2. Etiqueta – Un par clave-valor para especificar información de metadatos de imagen.

ejemplo:

LABEL ENV=”DEVELOPMENT”

3. correr – Se utiliza para ejecutar un comando sobre la imagen base y creará una nueva capa.

ejemplo:

RUN apt-get update
RUN apt-get install tomcat

4. Ordenar – Se utiliza para configurar el comando que se ejecutará primero cuando se inicie el contenedor.

ejemplo:

CMD [“java”, “-jar”, “app.jar”]

5. expuesto – Expondrá el puerto para acceder al contenedor. El contenedor escuchará en este puerto de red. Podemos usar este puerto para acceder a la salida.

ejemplo:

EXPOSE 8080

6. mantenedor – Proporcionará detalles del autor que creó esta imagen de Docker.

ejemplo:

MAINTAINER [email protected]

7. ruido ambiental – Se utiliza para establecer variables de entorno en pares clave-valor. Estas variables se establecen durante la creación de la imagen y están disponibles después de que se crea el contenedor.

ejemplo:

ENV DB_NAME=”MySQL”
ENV DB_VERSION=”8.0”

8. Copiar – Se utiliza para copiar archivos locales en el contenedor.

ejemplo:

COPY /target/devops.jar devops.jar

9. añadir – Es lo mismo que copiar pero con más funciones, como que podemos extraer tar local y agregar URL remota.

ejemplo:

ADD devops.tar.xz / .
ADD  /usr/local/devops/

10 punto de entrada – Comandos principales para configurar imágenes. Funciona igual que la instrucción CMD. La única diferencia entre CMD y ENTRYPOINT es que las instrucciones no se sobrescriben en ENTRYPOINT.

ejemplo:

ENTRYPOINT [“java”, “-jar”, “app.jar”]

11 volumen – Creará un punto de montaje con el nombre especificado.

ejemplo:

VOLUME /app/devops

12 usuario – Establecerá el nombre de usuario y el grupo de usuarios que se usarán al ejecutar la imagen.

ejemplo:

USER dhruv
USER admin

13 lista de trabajo – Establecerá el directorio de trabajo. Creará el directorio si no existe.

ejemplo:

WORKDIR /var/lib/

Aquí hay un Dockerfile de muestra para su referencia.

FROM ubuntu:latest
MAINTAINER Senthilkumar Palani "[email protected]"
RUN apt-get install -y software-properties-common python
RUN add-apt-repository ppa:chris-lea/node.js
RUN echo "deb  jammy universe" >>
/etc/apt/sources.list
RUN apt-get update
RUN apt-get install -y nodejs
RUN mkdir /var/www
ADD app.js /var/www/app.js
CMD ["/usr/bin/node", "/var/www/app.js"]

Permítame mostrarle un ejemplo simple para crear un Dockerfile de muestra y usarlo para crear una imagen.

Crear archivo Docker

Crear un Dockerfile:

# nano dockerfile

Agregue las siguientes líneas.En este ejemplo estamos actualizando e instalando empuje y ondulado Bolsa.

FROM alpine

RUN apk update
RUN apk add vim
RUN apk add curl
Dockerfile para Alpine Linux
Dockerfile para Alpine Linux

de acuerdo a CTRL+O y CTRL+X Guarde el archivo y ciérrelo.

Ahora tenemos el Dockerfile. Avancemos y construyamos la imagen usando Dockerfile.

Ten cuidado: si utiliza escritorio acoplablepuede ejecutar los comandos de la ventana acoplable como un usuario normal.

Cree una imagen de Docker usando un Dockerfile

Para construir una imagen desde un Dockerfile, simplemente ejecute:

# docker build -t alpine .

precaución punto (.) Al final.

Salida de muestra:

[+] Building 51.2s (8/8) FINISHED                                               
 => [internal] load build definition from Dockerfile                       0.1s
 => => transferring dockerfile: 104B                                       0.0s
 => [internal] load .dockerignore                                          0.1s
 => => transferring context: 2B                                            0.0s
 => [internal] load metadata for docker.io/library/alpine:latest          38.8s
 => [1/4] FROM docker.io/library/[email protected]:7580ece7963bfa863801466c0a  2.7s
 => => resolve docker.io/library/[email protected]:7580ece7963bfa863801466c0a  0.0s
 => => sha256:d7d3d98c851ff3a95dbcb70ce09d186c9aaf7e25d48 1.47kB / 1.47kB  0.0s
 => => sha256:530afca65e2ea04227630ae746e0c85b2bd1a179379 2.80MB / 2.80MB  2.4s
 => => sha256:7580ece7963bfa863801466c0a488f11c86f85d9988 1.64kB / 1.64kB  0.0s
 => => sha256:9b2a28eb47540823042a2ba401386845089bb7b62a9637d 528B / 528B  0.0s
 => => extracting sha256:530afca65e2ea04227630ae746e0c85b2bd1a179379cbf2b  0.2s
 => [2/4] RUN apk update                                                   4.3s
 => [3/4] RUN apk add vim                                                  3.5s
 => [4/4] RUN apk add curl                                                 1.3s 
 => exporting to image                                                     0.4s 
 => => exporting layers                                                    0.4s 
 => => writing image sha256:14231deceb6e8e6105d2e551799ff174c184e8d9be8af  0.0s 
 => => naming to docker.io/library/alpine                                  0.0s 
                                                                                
Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them

Siguiendo el comando anterior, Docker leerá de Dockerfile Guardar en el directorio de trabajo actual.Recuerda, hemos definido apk update, apk add vim y apk add curl comandos en dockerfile? Estas acciones también se realizarán automáticamente.

Si el Dockerfile se guarda en otro lugar, puede usar -f Logotipo como a continuación.

# docker build -f /path/to/a/Dockerfile .

Después de crear la imagen, podemos ejecutarla con el comando:

# docker run -it alpine

Este comando iniciará el contenedor Alpine y lo adjuntará.

/ # uname -a
Linux 8890fec82de8 5.10.104-linuxkit #1 SMP Thu Mar 17 17:08:06 UTC 2022 x86_64 Linux
/ # cat /etc/alpine-release 
3.16.1
/ # 

Si tiene Docker Desktop, puede ver los contenedores en ejecución en la pestaña Contenedores.

Ver contenedores en Docker Desktop
Ver contenedores en Docker Desktop

Así es como se construye una imagen de contenedor personalizada usando un Dockerfile.

Solo hemos cubierto lo básico. Puede hacer mucho más con un Dockerfile.Se recomienda que se refiera al oficial Referencia del archivo acoplable guía para más información.

LEER  "Lo que pasa en CentOS no pasa en Rocky Linux"

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba