Implementación de Dockerfile

No es claro el inicio del curso, mezclan muchas temas a la vez, o este es una continuación del curso de Docker?

Para ser el inicio del curso está mal organizado, creo que primero se debió explorar conceptos de DevOps y su cultura antes de entrar en herramientas, así como acá se requiere conocer Docker previamente más adelante puede ser cualquier otra

Manejar dependencias es algo muy importante cuando se trata de desarrollar software, no importa el lenguaje, debemos tener siempre nuestras dependencias “vendor” o “lock in”, es decir, que siempre se instalen una versión que ya hayamos probado.

El Dockerfile siempre empieza con un FROM, a través del cual busca una imagen base sobre la cual crear el nuevo contenedor.
Así como es importante fijar dependencias, es también muy importante manejar versiones exactas de las imágenes, porque pueden tener cambios en nuevas versiones que afecten o impidan el funcionamiento correcto de nuestros contenedores. La idea es tener siempre algo reproducible.

Es recomendable, que no corramos todo en /root; la buena práctica es crear un nuevo directorio donde copiemos nuestro servicio o aplicación. Para esto, utilizamos el comando WORKDIR dentro del Dockerfile.

Los container guardan layers o capas para hacer caché cuando un mismo Dockerfile vuelva a ser construido, y de esta manera, se toma menos tiempo dicha construcción al reutilizar capas similares. Por esto, es una buena práctica definir primero los comandos que no cambian la imagen y de último, aquellos que sí la modifican. De manera que si 2 capas cambian en una imagen de siete, sólo cambien las 2 al ser construidas y no más de ellas al no estar ordenados los comandos de forma correcta.
Al manejar dependencias con versiones exactas, no se debería volver a ejecutar el paso de instalación de las mismas en cada construcción de una imagen si no se modificó el archivo en donde se definen; y si se modificó, las dependencias que ya habían sido instaladas deberían tener exactamente el mismo comportamiento que la imagen anterior.

Es muy importante también utilizar .dockerignore, puesto que pueden ser transferidos archivos exclusivos de la máquina desde donde se construye la imagen, a ella. Uno de los casos más comunes de su utilización, es para evitar que las dependencias de nuestra máquina local sean añadidas a la imagen en construcción (las dependencias compiladas de un sistema operativo ocasionarán problemas en otro kernel).

Nuestro objetivo es reducir al máximo la posibilidad de errores.

Si la verdad en este video me siento aprendiendo de Doker mas no de DevOps.

# Buscar imagen origen
FROM node:11.1.0-alpine 

#Directorio en el que vamos a trabajar
WORKDIR /app

# 
ADD package.json package-lock.json /app/
RUN npm install

#Configuramos el puerto que se va a exponer
EXPOSE 3000

#
ADD . /app
#Ejecutar la razon por la cual se ejecuta node es para que se encuentre en el PID 1
CMD ["node", "index"]

No es muy claro que explique codigo y no se vea el codigo

Que curso mas mal hecho, porque no crean un verdadero curso de devops y una escuela junto a ello?

Se manejan algunos conceptos muy de Docker pero al dar una repasada en lo que menciona podemos continuar con el curso

Yo termine luego de algunas semanas el curso de Docker antes de continuar con el curso de DevOPs

Para acceder a este proyecto: https://github.com/elbuo8/platzi-scripts
(la carpeta de este curso es webapp)

De los cursos que he realizado en Platzi el de Docker ha sido el más universal de todos. Casi siempre se nombra o se utilizar para algo.

Todo esto se explica muy bien en la clase de Docker de Guido Vilariño! Un genioo. 💚

Para aprender un poco más del fichero package-lock.json para el control de las versiones de las dependencias les recomiendo el siguiente link

realize el curso de docker solo por que no entendi nada de lo que decias. ahora entiendo todo. pero ahora tengo una pregunta. ¿Por que usar ADD y no COPY?

El Dockerfile es una herramienta que nos ofrece la posibilidad de crear una imagen Docker a medida. Contiene una serie de instrucciones dentro de un fichero que harán que podamos crear imágenes Docker rápidamente.

Dicho de otra manera, Dockerfile es un documento de texto que contiene las órdenes a las que un usuario puede llamar desde la línea de comandos para crear una imagen.

La instrucción de terminal seria la siguiente:

docker build -t <Nombre que le quieras asignar a la imagen> . <El punto es el contexto del Dockerfile, en resumen el directorio donde se encuenta>

Definitivamente, est[e empieza siendo un curso de Docker, no del marco de trabajo como tal de DevOps

no entiendo como habla este profesor

Yo creo que es recomendable ver el curso de Docker antes de iniciar con este curso, si lo haces al contrario no vas a entender el curso

Node en la primera línea del Dockerfile

No es claro, no me gusta este curso, me confunde mucho

exelente clase

En este ultimo Curso hay como una mezcla de temas… Parece a modo de Repaso

Es recomendable hacer el curso de docker antes de este, pq sino te perderas

Me atrevería a decir que cuando tienes un buen control de las dependencias listadas en el package.json, entiéndase esto por buen entendimiento del versionado semántico, o semver, esta buena práctica de cachear la capa RUN npm install tiene más el propósito de optimizar el tiempo en que el contenedor se levanta, ya que conforme el proyecto va necesitando de más y más dependencias esta capa tarda hasta un par de minutos en ejecutarse pues /node_modules/ es un directorio habitualmente de gran tamaño. Si escribes una versión específica que no defina ni patch changes entonces no importa cuantas veces se descarguen las dependencias siempre serán las mismas.

Seria bueno agregar en la ruta de aprendizaje o requisitos previos sugeridos para este curso, el curso de Docker. Creo que de lo contrario es confuso

interesante

Entendiendo el Dockerfile