Imagínense ustedes que esa es una aplicación que en lugar de ser este blog, está utilizando cierta
comunicación con algún API, la cual se encarga de leer esa API o esa base de datos y hace la inserción
en otra base de datos como para hacer una sincronización o un manual o algo así.
Imagino que este procedimiento o este programa a más de uno le va a ser bastante interesante.
Y es muy sencillo.
Todo este procedimiento digamos que lo ocupamos montar y desplegar en un servidor y aparte ocupamos
mantener las versiones, porque puede ser que esta aplicación sea muy grande o que tenga diferentes
procesos, o que van a añadir más procesos, qué sé yo, ustedes podrían darle el uso a esta aplicación
como ustedes necesiten, pero digamos que en la vida real nosotros ocupamos crearnos una imagen para
simplemente montarla y ejecutarla, y si después sucede algún cambio, yo pueda mantener mediante versiones
fácilmente cambiar la versión, actualizarla y así sucesivamente, por lo cual tiene mucho sentido de
que yo quiera crear esta aplicación como una imagen de Docker para que simplemente yo llame Doc Run
el nombre de mi imagen y se acabó el asunto.
Ya estoy corriendo ese procedimiento sin preocuparme de mis dependencias, que esas dependencias sería
en este caso, no cron.
Aparte sería no como tal, porque obviamente puede ser que mi servidor yo no tenga node instalado,
entonces si yo no tengo Node instalado es imposible ejecutar el comando de node app porque va a decir
que no, no se reconoce como comando interno o externo, entonces no voy a poder ejecutar la aplicación,
entonces tengo varias dependencias y aparte no Chrome tiene otras dependencias que necesita como Yuyo
ID y este bin ok bueno, tiene esas dependencias en general, no el yuyo ID básicamente.
Entonces también hay una definición de cómo fue construido ese archivo, entre otras cosas, pero la
verdad es que todo lo de los módulos de no se maneja de manera automática.
Entonces todas esas son mis dependencias.
Y obviamente no sólo es Node, sino que también yo necesito un sistema operativo en el cual va a correr
el procedimiento.
Porque si ustedes se fijan, yo no monté un apache o un servidor Apache para phpMyAdmin.
Yo no sé, yo no monté ningún servidor de Node para correr mi aplicación de Pokémon.
Yo no monté nada de eso, porque esas imágenes proporcionan todo lo que nosotros necesitamos.
Es lo mismo que nosotros tenemos que hacer y tenemos que decirle a Docker cómo crear todo lo que necesita
la aplicación para poderse ejecutar.
Entonces vamos a comenzar ese camino, ese camino de la localización.
Todo comienza con un archivo llamado Docker File.
Este Docker File imagino que ustedes ya lo habrán visto más de una vez.
Y si no lo han visto, bueno, si ya lo han visto o simplemente se han asustado con un montón de instrucciones.
Y si nunca lo han visto, tranquilo.
Vamos a empezar paso a paso, porque para mí es importante que ustedes comprendan cada cosa que vamos
a ir haciendo y vamos a comenzar desde lo más pequeño y luego vamos a llegar hasta múltiples pasos de
construcción.
También vamos a crear múltiples versiones basados en diferentes arquitecturas de procesador, que eso
es algo bastante útil que tenemos que saber.
Y así vamos a ir creciendo en complejidad.
Entonces todo comienza con el primer paso.
Todo esto, todo lo que vamos a colocar en este Docker file no son más que instrucciones que nosotros
vamos a empezar a seguir a Docker para que construya la imagen.
Si ustedes buscan aquí PostgreSQL en otros Docker punto com, no hace falta que lo hagan solo.
Pues miren esta explicación.
Cada una de estas líneas que ustedes están viendo aquí es una instrucción de Docker File.
Básicamente aquí le dice que se agregue ciertos archivos.
Un comando que se ejecutó, un shell command, otro shell toman una definición de variable de entorno,
o sea el comanche, el command variable de entornos, el comanche, el comanche, el comando variable
de entornos, el comanche, El command más variable de entornos Shell commands La definición de un volumen
Copiar ciertos archivos, un punto de entrada, un stop signal y tenemos la exposición de un puerto
y el comando en el cual se ejecuta.
No pretendo que ustedes sepan qué es lo que hace cada una de estas cosas.
No, no es la idea.
Pero cada una de esas instrucciones va creando diferentes layers o capas que le van a decir a Docker.
No sé si ustedes se acuerdan cuando descargamos una imagen que había como varias descargas.
Esa varias descargas simultáneas son las capas que está descargando y así funciona básicamente, lo
cual ayuda mucho saber y reutilizar capas en el caso de que no haya cambiado algo.
Pero ya vamos a ver eso muy pronto.
Olvídense de lo que acabo de decir, escriban node y eso sí, háganlo, por favor, vengan conmigo,
vamos a irnos a Load, seleccionen la imagen oficial que esta es súper popular.
Más de 1 billón de descargas Es estúpido o es estúpida la cantidad de descargas que tiene?
Y luego busquen la parte de Bueno, bajemos un poco más.
Van a ver que tenemos un montón de tags.
Por cierto, todas estos tags que la gente tiene, por ejemplo el 19.3 punto 15, 19.2 Alpine, todo
esto, todo lo que está aquí es el mismo tag, o sea, yo sé que es el mismo, apuntan a la misma imagen,
sólo que tiene diferentes nombres.
Y aquí ustedes van a ver que está el proceso de construcción de ese Docker.
Filmen el Docker file y aquí está From al point 3.15, que ustedes ya deberían de saber que es el Alpine,
porque lo he explicado muchas veces, que también ustedes lo tienen en el.
La guía de atajos Alpine no es más que una versión de una distribución súper ligera, etcétera, etcétera
Y ahí están, con un montón de pasos.
Cada paso que hace aquí es una capa y hay pasos como este.
No hace falta que ustedes entiendan lo que dice aquí, pero este paso de Run y hay un montón de comandos
que está aquí.
Por ejemplo, ejecuta este comando y añade y ejecuta este, y después añade este, y después ejecuta
y después ejecuta ese lo que está haciendo con todo este paso, todo ese paso hasta aquí es que ejecuta
todo esto, le dice, le dice a Docker, ejecuta todo esto y crea una capa con el resultado del mismo.
Es decir, esto va a ver que si al día de mañana no hay ningún cambio en estas instrucciones, va a
ser la misma capa y no se vuelve a ejecutar una segunda vez porque lo demás va a estar en caché y funciona
muy rápido después y así sucesivamente.
Luego tenemos una variable entorno que ejecuta sea el comando o en este caso son una serie de instrucciones
de descomprimir otras cosas que eran directorios.
En fin.
Y eso es todo lo que está haciendo, básicamente.
Ok, regresemos.
Ups, regresemos.
Lo cerré sin querer, pero pensé que lo tenía abierto en otro lado.
Entonces todo va a comenzar.
Toda nuestra aplicación necesita empezar por un punto.
No nos ofrece un Alpine, es decir, un Node que ya habían instalado en un Linux.
Esto es lo que significa el Alpine con Node.
Básicamente quiero tomar una versión de Linux lista para producción, o sea, lista para que yo la pueda
utilizar en la vida real que ya viene con un Node preinstalado.
Si nos vamos a la parte de tags hay muchos y van a ver que las imágenes comprimidas.
Son muy grandes, pero si ustedes buscan al PIN, por ejemplo, van a ver que las imágenes de Alpa N
son más pequeñas.
Ojo, que aquí está comprimido, no está descomprimido.
Comprimido es ese peso, pero descomprimido puede ser 100, 150 megas, etc.
Ok, van a buscar la versión 19,2 menos Alpine.
Esa es la versión que yo quiero utilizar y esa es la que vamos a usar.
Pero puede ser que ustedes quieran una versión 14 o una versión 12, la versión que necesite su aplicación
para funcionar.
Entonces, el primer paso que vamos a hacer es tomar esta versión.
Pueden venir aquí, copiarse este pedacito de código que es Node, y el tag es 19.2, es decir, la
versión 19 de Node menos Alpine.
Si no dice Alpine, también ustedes van a poder encontrar otras versiones, como por ejemplo esta 19
punto Two y esta es la versión de Alpine que está usando, porque Alpine también tiene otras versiones.
Si quieren usemos esta de aquí porque es un nombre teóricamente más complicado, pero no es nada del
otro mundo.
Podemos tocar este botón y regresemos a nuestro Docker File.
El primero.
La primera instrucción usualmente viene como o con la palabra from y ustedes empiezan a escribir from
y aquí me dice from.
Imagen base.
Usualmente lo que nosotros vamos a hacer.
Usualmente lo que nosotros hacemos es que nuestros códigos van a estar basados en otra imagen.
Técnicamente, ustedes pueden crear su imagen de absoluto cero, pero usualmente y la mayor parte de
las veces y el 99% de las veces, ustedes van a trabajar con imágenes ya creadas.
Entonces, básicamente aquí le digo de esta imagen es el punto inicial.
Ok.
Esta es nuestra, nuestra entrada.
Aquí nosotros básicamente tenemos nuevamente nuestro sistema operativo, que sería el Alpine, la versión
de Linux, y adicionalmente esa opción de Linux ya viene con Node instalado.
Ok, ese va a ser nuestro primer paso.
Otra cosa que vale la pena mencionar es que esta versión de Linux, esta versión de Linux que ya generó
Node, viene con una carpeta interna llamada APP, que ya viene una carpeta internamente que se llama
App, que usualmente ahí se usa para colocar mi aplicación.
Pero ustedes pueden crear otros directorios porque básicamente es imagínense como si tuvieran una máquina
virtual ya previamente configurada.
Entonces el siguiente comando que yo quiero hacer es escribir Working directory y voy a especificar
ah, el slash app.
Es decir, esto es muy similar a que yo haga un cd, por ejemplo, voy a poner aquí arriba solo para
que no nos equivoquemos, es como hacer un cd a la carpeta app.
Lo mismo que hemos venido haciendo.
Quiero que cambiemos de directorio al app, entonces todos los directorios o path relativos que yo voy
a poner aquí van a estar ejecutándose dentro de este directorio.
Ok, este es mi segundo paso.
Recuerden, el All Point tiene esta carpeta de directorios.
Van a ver que también tenemos el el user y tenemos lib y tenemos otro montón de carpetas ahí adentro.
Ok, nos movemos de directorio.
Perfecto.
Ahora.
Qué es lo que nosotros ocupamos para ejecutar nuestra aplicación, por ejemplo?
Bueno, van a ser los archivos de la aplicación, porque ahorita es como que no tuviéramos nada.
Es decir, no tenemos nada de nuestra aplicación, es decir, nuestro cron, O sea, este app JS no
existe y es como que no tuviéramos nada, nada, nada, nada de proyecto, simplemente tenemos el Linux
con Node instalado y nos movimos al directorio app nada más.
Eso es todo lo que hacemos.
De alguna manera yo tengo que copiar los archivos que hacen mi aplicación.
Por ejemplo, ocupo copiar el app JS porque está en mi aplicación, por decirlo así, y también voy
a ocupar el paquete JSON porque aquí está el comando de inicio y también me dice qué dependencias son
las que tiene mi aplicación.
Entonces voy a escribir comando de copia y van notando que la sintaxis es que cada instrucción va capitalizada
y eso tiene que hacerlo así.
Me dice el source de donde lo voy a copiar, que eso sería prácticamente mi proyecto, de donde me encuentro.
Y el destino es el relativo al working directory de dentro del contenedor de la imagen que estamos creando.
Bueno, dentro de la imagen que estamos creando, esto no es un contenedor dentro de la imagen que estamos
creando.
Entonces yo puedo definir varios archivos de una vez y varias sintaxis y lo demás.
Es decir, quiero copiar el archivo app JS y también quiero copiar el package JSON, es decir, voy
a copiar este.
Que hace es escribirlo bien y voy a copiar el app.
Esos dos archivos son los que hacen mi aplicación y el destino es el último lugar donde yo lo voy a
colocar.
Si yo no hubiera escrito el Walking Dead History tendría que poner es las app, es las y quiero que
lo pegues aquí, pero como tengo la línea de Walking Directory, entonces voy a ponerlo en el punto
de slash, que esto ya está.
El destino sería el slash app.
Ok.
Va a copiar este archivo, este otro lo va a pegar por acá.
Como el video ya se está haciendo un poquito largo.
Qué les parece si terminamos este video acá y continuamos en la siguiente clase donde vamos a construir
nuestra imagen?
Que solo faltan dos comandos.
Ya, pero dejémoslo así.