Docker y Kubernetes


language: ES

                  WEBVTT
Vamos a empezar a trabajar con la parte de Docker y vamos a empezar a seguir este How-To,
este cómo, para instalar, cómo instalar la tecnología de Docker.
En este caso va a ser en la distribución Ubuntu y vamos a instalar precisamente esta
parte de Docker.
Para la parte de Windows
vamos a tener, si entramos nosotros al sitio principal de Docker,
vamos a tener aquí dentro de los productos en Docker Desktop, que es una aplicación,
una aplicación que nos va a permitir usar de esta manera con una GUI en el Docker y como tal,
pues es gratuita, pero tiene precisamente algunos temas ya para, de costos cuando ya estás usando
lo permite refrescar precisamente los repositorios de nuestro Linux.
Ahora vamos a instalar estos componentes, algunos de ellos yo creo que ya están instalados,
vamos a ver si nos deja pegar,
se los voy a ir poniendo en el chat para que igual los puedan copiar.
Aquí ya los pegué en el chat.
Ok, algunos de ellos me han dicho que ya están instalados y nosotros los vamos a instalar.
Si les sale mensaje de que hay software para actualizar, vamos a crear este comando.
Y lo que va a hacer es actualizar todos nuestros paquetes teniendo cuidado
de los paquetes que actualizan, en este caso a mi nada más con DNS Mask.
Y nada más cuidemos que esté uno de los servicios.
Voy a ok y listo.
Les puse el comandito que usé para actualizar mi Ubuntu,
si quieren ponerlo ahorita y vamos a ver que actualiza.
Listo, según esto les actualizo.
Ahora bien, lo que vamos a hacer
es continuar con la instalación.
Ahora venimos con este comando,
Ya me funcionó.
Ya pegué los principales, ahorita también los voy declarando.
Si se atora alguno, me levanta la manita.
Y nada más, permítanme un momento, voy a poner mi micrófono en mi otro momento.
Después de que ya lo tengan instalado,
de que lleguemos a la parte de la instalación,
vamos a ejecutar esta parte.
Y con eso debemos tener la capacidad de ejecutarlo si no sale el sudo.
Vamos a tener que ponerle un password al usuario Student,
que es el que deben de tener en su sesión.
Esto lo vamos a hacer con este comando de aquí.
Y Student es el usuario que estamos usando.
Entonces lo ponemos así, sería sudo passwd student,
le ponen el password que ustedes quieran.
Y lo que vamos a hacer es teclear el comando.
Este de aquí, el primero que les puse,
el sudo usermod-ag-docker y user en mayúsculas.
Lo tecleamos, le van a dar enter, no pasa nada,
eso ya nos está agregando al grupo.
Y después vamos a teclear su user.
Tiene que estar en mayúsculas.
Cuando demos este comando, nos va a pedir el password del usuario,
es el que acabamos de ponerle.
Entonces los ponemos y lo vean nuevamente dentro de la sesión.
Tecleamos el comando groups, y aquí ya vamos a ver a Docker,
que ya pertenezco al grupo de Docker.
Con esto ya nos va a permitir que sin usar el sudo,
usemos el comando Docker.
Entonces no sé si tienen duda,
y si no tienen duda, lo pueden ir ejecutando.
Al final lo que vamos a tener es la capacidad de hacer esto.
Sale sin el sudo, hay que ejecutar el comando Docker PS,
y podamos ver el resultado sin ningún problema.
No, es en partes.
Primero es el sudo usermod, ese es un comando,
y el segundo comando es el su user.
Y hasta ahí, ya el 3 y el 4 lo podemos omitir.
Bueno, el 3 nada más es para verificar,
y hasta ahí si quieren se quedan hasta el 3.
Tú se lo vas a otorgar, si no se lo has puesto,
con el último comando que les puse en el chat,
se lo podemos poner.
Sería sudo passwd espacio student,
y ahí ya te pregunta qué password le quieres poner.
Ya llegamos hasta aquí, me levantan la manita,
y ahora ya estamos en esta parte de sale,
que puedan encontrar este comando, el Docker PS,
sin sudo.
Lo pongo aquí en el chat.
A ver, vamos a ver.
Luis, voy a hacer el grande aquí tú.
Aquí es donde dices que no te deja, ¿verdad?
Su user.
A ver, creo que yo puedo tomar tantito tu control.
Puedes separar del guión en la parte del user,
donde empieza el signo de $.
No creo que sea eso, pero bueno, sí, eres.
Ahí está.
Ya.
Sí, sí, luego los detallitos, no te preocupes.
Ahí está.
Entonces hasta aquí pues ya instalamos el engine de Docker,
y ya tenemos la capacidad de usarlo.
Estamos, todo esto se hace generalmente, pues,
en la mayoría, más bien en todos los,
en todas las distribuciones Linux,
tenemos que buscar el auto, dependiendo de nuestra distribución.
En este caso fue para Ubuntu.
Les repito, para el tema de Mac o el tema de Windows,
pues es un poquito distinta la situación, ¿no?
Ahí sí ya nos podemos descargar aplicaciones que ya nos permiten,
ya hacen todo este proceso de instalación,
y ya nos permiten directamente usarlo, ¿sale?
Pero básicamente también esto nos sirve para entender un poquito
la estructura precisamente de este engine
y de lo que vamos a estar trabajando.
Entonces ya que tenemos nuestro engine instalado de Docker,
lo que vamos a hacer, y bueno, que lo podemos usar sin,
¿cómo se llama?
Sin que necesariamente tengamos privilegios de sudo,
pues lo que vamos a hacer es empezar a conocer
algunos de los comandos que podemos usar, ¿vale?
Y sobre todo, pues, vamos a empezar a ver
lo que es el ciclo de vida de un contenedor, ¿vale?
Ahí se ve en mi pantalla, pero se ve como muy raro, ¿verdad?
¿Sí la ven bien o no?
Sí, eso es lo que estoy viendo.
Es que está acá, pero no sé por qué.
Está haciendo cosas raras, permítanme.
Bueno, no queremos estar haciendo así, pero vamos a ver.
¿Sale?
Vamos a hacer un poquito más grande.
Y vamos a empezar.
Pues el ciclo de un contenedor, el ciclo de vida de un contenedor
va a estar dictaminado por los pasos que tenemos aquí,
que básicamente, pues, va a nombrarnos
en el estadío en el que se encuentra en nuestro contenedor.
Y pues básicamente vamos a empezar por el tema de la creación.
¿Qué me dejaste uno?
Aquí está.
El de la creación.
Luego vamos a tener la parte del inicio, la ejecución,
la detención, el detener nuestro contenedor y la eliminación.
En los pasos de creación y de posible,
más bien, en la parte de creación lo vamos a conocer
en nuestro contenedor como imagen.
Lo vamos a referir a él como una imagen.
Y vamos a, en realidad, a tener el mote de contenedor
a partir de que está iniciado y en ejecución.
A partir de aquí nos vamos a referir como contenedores
porque en ese momento es cuando nos vamos a estar refiriendo
a ya tener en funcionamiento nuestra imagen.
Y en ese punto, pues, es nuestro contenedor.
Y no sé si alcanzan a ver aquí la imagen.
Y en este momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Y en ese momento, pues, es nuestra imagen.
Sí, así es.
Contienen de base distintos archivos.
Y listo.
Tenemos el Statue2App.
Y aquí vamos a hacer...
Docker...
Ahí está nuestra línea de la tarita.
Siempre se me olvida.
Docker.
Aquí vamos a poner la imagen que vamos a tomar.
OK. Hasta aquí...
OK. Hasta aquí...
Lo que hice fue generar un directorio que se llama hola mundo.
Una pequeña aplicación.
Está en Python.
Es esta de aquí.
Sabe que nos tiene que contestar solo el hola mundo.
Y...
No sé si...
Dejen que les pegue...
Que les sale más rápido.
Les pego el código en el chat, ¿verdad?
OK. Vale.
Entonces...
Ahí va para allá.
Lo tienen en el chat.
Y tiene que tener esta estructura.
No sé si ya antes habían programado en Python.
O qué lenguaje es en el que a lo mejor han tenido ya experiencia programando.
Vale. Mientras...
Empecemos esto.
Ponemos ese código ahí en Python.
Lo que hicimos fue generar la carpeta.
Poner el código.
Y luego vamos a generar este archivo que se llama Dockerfile.
¿Vale?
En el archivo Dockerfile...
Vamos a poner lo necesario.
Para que se genere nuestra imagen.
Como base vamos a tomar esta...
Esta imagen.
De este repositor que se llama Tiagolo.
Y vamos a por ejemplo a buscar aquí en el...
En el Docker Hub.
Vamos a ver qué opciones tenemos.
Ponemos...
Pegamos...
Miren aquí está.
Esta es una imagen.
De un usuario que se llama Tiagolo.
¿Cuál es la diferencia?
Si se dan cuenta.
Como aquí cada uno de nosotros podemos hacer un repositorio y publicarlo.
Pues luego la gente de seguridad dice no, no, no.
No puedes tomar imágenes de cualquier lugar.
No sabemos que contenga.
Hoy en día se pueden auditar las imágenes.
De entrada.
Pero generalmente cuando...
Pues tenemos...
En la curia de revisar qué es lo que estamos usando.
Pues podemos usar herramientas que nos permitan auditar las imágenes Docker.
Y ver qué es lo que hace, cómo fueron construidas, etc.
Pero si no reparamos en ello.
Recordemos que aquí hay...
Muchos usuarios subiendo sus imágenes.
Y en efecto no sabemos cómo fueron creadas.
Qué componentes tienen.
Si no lo revisamos.
Entonces generalmente...
Lo que se hace es que como en las redes sociales.
Todas las empresas, comunidades de desarrollo importantes.
O que tienen ya cierto tiempo trabajando.
Cierto renombre, digamos así.
Se identifican con este distintivo.
El Docker Official Image.
Recuerden el archivo que tenemos que crear se llama Dockerfile.
En el directorio que generamos.
Y tenemos que poner esto.
Así.
No tiene que verse con el archivo.
Hasta aquí.
Tienen alguna duda, algún comentario.
Así es.
Es correcto.
La OSI Image.
Se me olvidó.
Open Source OSI.
En busco el sitio.
Y digamos que ahí ya es...
Como el estándar.
Para tú generar una imagen.
Pura, así, limpia.
Desde cero, desde una máquina.
Desde una versión...
De tu sistema operativo base.
Y eso pues ya requiere.
Pues obviamente.
Un conocimiento un poco más avanzado.
Tanto del sistema operativo.
Como del mismo runtime.
De Docker.
Sale.
Entonces, nosotros generalmente.
En el uso o en el aprendizaje de Docker.
Lo primero que vamos a ver.
Es como generar a partir de una imagen.
Las nuestras propias.
Y también.
Las nuestras propias.
Y todas las que están disponibles.
Para poderlo hacer.
Sale.
Ahí también hay mi pantalla, ¿verdad?
Esta es, digamos, el sitio.
De la fundación Linux.
Donde se van a marcar.
Digamos.
El cómo debemos construir.
Imágenes.
Para contenedores.
De manera estándar.
Porque Docker no es el único producto.
Actualmente para temas de contenedores.
Han salido forks.
Y por ejemplo.
Red Hat.
Tiene su propia.
Su propio runtime de contenedores.
Que se...
Potman.
Que se llama el runtime.
Y pues es similar.
La verdad es que hacer.
Ser un producto open source.
Y código abierto Docker.
Pues tú lo puedes tomar y lo puedes modificar.
Entonces Red Hat lo ha tomado.
Ha tomado algunas funcionalidades.
Y ha generado su propio producto.
Si quieren verlo así.
Pero entonces para que todo sea de alguna manera.
Compatible entre sí.
Que no nos perdamos en incompatibilidades.
Pues se generó la gente.
Y listo. Ya la generó.
Aquí ya generó.
De todas estas.
De toda la imagen generó.
De acuerdo a lo que fue trabajando.
Estas pequeñas capas.
Ya la generó nuestra imagen.
Y la exportó en automático.
A nuestro registry local.
Entonces si yo le doy lo que...
Ah.
La imagen.
Acá. Que fuese mal.
Que ponemos el de ese.
Y aquí ya la tenemos.
Sale.
Es hola mundo. En la versión 1.0.
Este es el ID.
Y ya la tenemos. Ya generamos.
Nuestra imagen.
Sale. Entonces ahora vamos a ver si corre.
Vamos a ponerle al nombre del contenedor.
El nombre del contenedor es hola contenedores.
Por el puerto 80.
Y vamos a poner.
Esta imagen.
Ahí ya inició.
Si se dan cuenta.
Aquí nos dice que está escuchando por el puerto 80.
Entonces las.
En toda la red.
Todas las direcciones posibles.
Y nosotros le damos aquí.
A ver si nos abre el contenedor.
Copiarlo.
Vamos a esta parte de aquí.
Y ahí está.
Tenemos nuestra primera aplicación.
Corriendo.
Sale.
Hasta aquí vamos todos.
¿Dónde de este lado?
A ver. ¿Dónde? ¿Dónde?
¿Dónde andan? ¿Dónde andan?
Están de este lado.
¿Lo hiciste en tu pantalla? Sí.
Aquí estamos viendo que está corriendo nuestro.
Nuestro contenedor.
Sale.
Y de hecho por ejemplo aquí ya estamos viendo.
Que ejecutó el start.sh.
Entonces es muy probable que tomó.
La aplicación que viene aquí.
Del start.sh.
Y podemos hacer dos.
Les voy a mostrar dos cosas que podemos hacer aquí.
Entonces podemos conectarnos.
A nuestro contenedor.
En ejecución.
Es el que tenemos en la otra pestaña.
Vamos a usar docker.
exec.
Menos it.
En la id de nuestro contenedor.
Que es este de aquí.
Y vamos a decirle que nos ejecute.
El comando bin bash.
Para que tengamos una sesión.
Activa del.
Pronte de shell.
Del shell de bash. Perdón.
Y a partir de aquí. Podemos explorar.
Lo que está sucediendo.
En nuestro contenedor.
Básicamente el exec.
Es para ejecutar comandos.
Podemos ejecutar cualquier comando.
Dentro de nuestro.
Contenedor.
Y en este caso la opción de.
It. Es para que sea interactivo.
Que quiere decir que se va a quedar.
Activo. Mientras se ejecuta.
El comando.
Si yo se lo quitará.
El bin bash. Aunque se ejecute.
En el momento en que se ejecuta. Se vuelve a cerrar.
Y no tiene mayor.
Impacto en el que podamos trabajar.
Dentro de nuestro contenedor.
Si lo vemos de esa forma.
Pero a ver.
Nosotros le diramos bin.
Ls por ejemplo.
Ya se cerró.
Ya se cerró.
Bueno ahora vamos a levantarlo.
Vamos a ponerle.
Aquí.
Está.
Aquí.
Aquí.
Y.
Está.
Y la ID. ¿Cuál es la ID?
¿Qué es este?
¿Cómo le pusimos?
La contenedora.
No.
No.
La contenedora.
Aquí ya estamos viendo.
Otro estadio de nuestro.
Contenedor.
El run.
Es.
Para iniciar la ejecución.
De nuestro contenedor.
Y en ese momento se va a generar una ID.
Y se le va a llamar.
De acuerdo a lo que nosotros le pusimos.
Cuando yo intenté.
Volver a ejecutar.
El mismo comando. Que es el run.
Con base al nombre que le pusimos.
Que es aquí.
Nos dice no.
Y ahora yo puedo ejecutar.
Como si fuera.
Digamos que el run es como ejecutarlo cada vez.
De cero.
Y me dice que yo ya ejecute.
O en algún momento ya se ejecutó.
Un contenedor.
Con ese nombre.
Entonces yo ya hasta aquí lo tengo con este ID.
Entonces para volverlo a iniciar.
Dado que lo detuvimos.
Que es uno de los.
Parte del ciclo de vida.
Que vamos a poner que en este caso va a ser un.
Start al nombre del contenedor.
Que quiere decir que momentáneamente.
Todos nuestro.
Nuestra configuración que en ese momento.
Ejecutó nuestra.
Imagen.
Y que generó unos volúmenes.
Aunque son temporales.
Si quieren verlo así.
En este momento están guardados.
Y que el estatus de nuestra.
Aplicación pues se mantiene.
En esa.
Contenedor.
El ID.
En este caso no cambió el ID.
Perdón.
De nuestro contenedor.
Entonces ahora si vamos a darle un docker exec.
Y aquí ya está nuestra.
Nuestro LS.
Sale.
Así es como podemos darle comandos.
Hacia el interior de nuestro contenedor.
Pero que pasa.
Lo que yo les comentaba.
Queremos una sesión interactiva.
Que quiere decir que vamos a esperarnos.
Que.
Nuestro contenedor.
Ejecute lo que en este caso el comando.
Que le pedimos y que nos muestre.
Todo el momento.
En todo momento esa.
Sesión de ejecución.
Vamos a poner el.
El ID del contenedor.
Y el comando que en este caso.
Se suena a cell.
Y listo.
Estamos conectados.
Aquí ya estamos viendo que en efecto.
La imagen ya traía un.
Un punto pi.
Y lo vamos a ver aquí.
Sale.
Aquí ya tenemos un.
Prestar.
Sale.
No se si vamos igual.
Ya te crearon esos comandos.
No.
Se los paso por el chat.
Ahorita tienen funcionando ya su.
Contenedor verdad.
No la han cerrado.
O ya.
Ok puedes darle el build.
Para generarlo.
Así claro.
Build.
En este caso.
Es el nombre de la imagen que le pusimos.
Que fue hola mundo.
Ya se los puse.
En el chat.
Para empezar.
Se genera.
Un.
Entorno.
Totalmente separado.
De lo que es tu.
Tu sistema base que en este caso.
Se genera.
Totalmente separado.
Y lo que sucede.
Es que estas corriendo aquí.
Una instancia digamos.
De sistema operativo.
En este caso.
Del que descargamos.
Y ya que esta.
Que va a ejecutar directamente.
El.
Que va a ejecutar nuestra aplicación.
Pero tu no lo puedes ver.
Directamente.
Como si fuera parte de algún directorio.
De tu sistema operativo.
Si no tiene una capa.
De.
Arreglos.
De.
De organización de la información.
Que lo que hace es que.
Lo cubre.
Dentro de.
Dentro de lo que es tu sistema operativo.
Y el contenedor.
Sale.
Se generan unas cosas que se llaman.
Volumes.
Que supongo que esta aquí.
En.
Aquí tenemos que ser.
Super suave.
Volumes.
Volumes.
Volumes.
Volumes.
Si.
Toda ejecución.
Nos va a generar.
Unos bloques.
En este caso.
Como si fueran volúmenes.
De disco duro.
O de espacio.
Dentro del engine.
De docker.
Y aquí por ejemplo este es uno.
Que es precisamente.
El.
Contenedor que estamos corriendo.
Ahora tenemos un comando.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Volumes.
Así es.
De hecho.
Lo tengo acá.
Mira la estructura que tiene.
Es la siguiente que de hecho quizás.
Me faltó.
Hacer.
El cambio.
Aquí tiene un main.
Y aquí tiene el prestar.
Sale.
Aquí lo que va a ejecutar.
Luego cuando arranque.
En.
El contenedor.
Es este script que dice prestar.
Sale.
Y aquí tiene las instrucciones.
Para ejecutar.
En este caso.
La aplicación.
Sale.
Entonces aquí.
Main.
Ok.
Aquí ya tiene.
Lo que es la aplicación.
Y de hecho por eso nos está mostrando.
El mensaje.
Lo que tendríamos que hacer.
Es.
Salvo.
Vamos a ajustar.
Un poquito.
Y lo que voy a hacer es.
Cambiarla.
Que se llame.
Main.
Apope.
.pelle.
Vamos a sobre escribir.
La que ya trae ahí.
Podría funcionar.
Aquí.
Aquí en el Docker.
Bien.
Y aquí podemos hacer dos cosas.
Vamos a ver.
Mesh.
LS.
Tenemos aquí.
El hola mundo.
Con el 1.0.
Aquí tenemos.
Lo que es.
Y está corriendo nuestro.
Contenedor.
Lo vamos a detener.
Lo eliminamos.
Lo que estamos generando es.
Otra.
Pequeña versión.
Tenemos.
Mesh.
Tenemos la versión.
1.0.
Y la versión 1.1.
Y aquí lo que sucede.
Que estamos generando la imagen.
Con los directorios.
Como lo mostrás un momento.
Por dentro del.
Contenedor.
Ya generamos.
Que nos generamos.
Cuando entramos al contenedor.
En ejecución.
Lo que nos mostraba era.
Precisamente.
Que ya tenía un directorio.
Que se llamaba app.
Y que ahí tenía una.
Main.pelle.
Y ese era el que estaba ejecutando.
De manera que nosotros accedíamos.
O nos respondía la aplicación.
Lo que venían en esos archivos.
Ya están dentro.
El decir que generas una imagen.
Precisamente como un.
Como un compreso.
Como un archivito de los de.
Virtual box.
Lo generaste.
Y ya adentro lleva todo lo necesario.
Para la aplicación. No necesitas metérselo.
En tiempo de ejecución.
La diferencia entre la virtualización.
Pura y los contenedores.
Es que tú vas a preparar.
Previo.
A la ejecución de tu aplicación.
El ambiente.
Y luego todo empezar a instalar a mano.
Todo esto.
Lo automatiza.
De manera que lo que queda.
Es esta imagen.
Es un archivo.
Que se generó.
A partir de la imagen.
Es como si hubieras agarrado una carpeta.
Y ahí hubieras metido todo.
Pero estamos hablando.
De que no solamente son archivos.
Así pegados.
Digámoslo.
Ahora vamos a ver.
Copio lo que le pedimos que copiara.
Y nos muestra.
Luego que le pedimos que nos muestre.
No contesto.
Si si está en port.
Lo que no parece ser.
Es que si está ejecutando la aplicación.
Así está bien.
Porque lo vamos a conectar.
Al contenedor.
Que sería este de aquí.
Ya está nuestra aplicación.
Pero.
Hábamoslo de gusto.
Que no inició.
Con que no está.
Bueno.
Digo que es lo que tenemos que hacer aquí.
Que lo componemos.
Pero.
Vamos continuando con.
La presentación.
De aquí de los comandos que.
Estuvimos viendo.
Pues básicamente ya.
Vimos como ejecutar una imagen.
Como construir una imagen.
Como eliminar una imagen.
Descargarla.
Detener un contenedor.
Eliminar un contenedor.
Ah bueno.
Los logs del contenedor.
Y los que estamos buscando.
Entonces ahorita hemos visto.
Los comandos.
Que comúnmente vamos a estar usando.
Para construir.
Y para ejecutar nuestros.
Contenedores.
Ahora bien.
Antes de que pasemos a la parte de redes.
Esto de.
La ejecución de imágenes.
Docker.
Nos ayuda.
A que.
Podemos.
Compartir.
Podemos trabajar.
Todo este tema de.
De los contenedores.
A que me refiero.
Por ejemplo esta imagen.
Que está aquí.
De tipo Linux.
AMD 64.
Que son las máquinas.
De tipo Intel.
Como las llamadas.
IBM Z.
IBM Power.
Power PC.
X86.
Que son las máquinas más.
Algunas viejitas.
Pero siguen siendo Intel.
ARM.
Este tipo de arquitecturas.
Son dependiendo del tipo de procesador que usamos.
Y entonces podemos tener la lista.
De todas las imágenes que podemos usar.
En estos ambientes.
Perdón.
Y nosotros a la hora de construir.
También podemos indicarle.
Para que.
Arquitectura vamos a construir la imagen.
Vale.
Entonces depende.
Si por ejemplo.
Nos vamos a basar.
En alguna imagen.
Que si tenga.
Una arquitectura.
O esté preparada para.
El tipo de procesador.
Que vamos a utilizar.
Podemos indicarle.
En el build.
Que vamos a utilizar una arquitectura.
En particular.
Aquí por ejemplo.
Build.
Vamos a ponerlo.
Vamos a poner por ejemplo.
Quizás nos de un error.
Porque no estoy seguro que la imagen.
Esté preparada.
Para la arquitectura ARM.
Por ejemplo.
Vamos a ponerle Docker.
Docker.
Build.
Build X.
Y vamos a ponerle classical.
Vamos a ponerla a mundo.
1.2
A ver si nos funciona.
Y lo vamos a construir.
Ahora.
De hecho creo que si lo hizo.
Aquí me generó.
Una imagen.
1.2
Pero cual es la diferencia.
Que lo que me construyo.
Es.
Directamente para la plataforma.
ARM.
Entonces nosotros podemos.
Crear nuestras imágenes.
Aunque estemos trabajando en una máquina X86.
Para alguna plataforma.
Como el ARM.
O para las que vimos de IBM.
O desde una máquina IBM.
Por ejemplo.
O una Mac. Por ejemplo.
Que actualmente ya tienen los chips ARM64.
Podemos.
Crear una imagen que corra en un servidor.
De 64 bits.
De tipo Intel.
Entonces.
Docker nos da la capacidad.
De generar imágenes.
Para otros entornos.
Y que nosotros.
Podemos construir.
Y luego.
Compartirlos.
Por medio de un.
De un.
Docker registry.
O como les mostré.
De manera manual.
Entonces.
Con esto.
Es otra funcionalidad.
Que nos brinda ventaja.
A la hora de generar.
Para los ambientes de tipo Docker.
Que no solamente.
Podemos generarlos para un solo tipo de procesador.
Sino desde la máquina.
Donde estemos trabajando. Podemos generarlo.
Para el tipo de procesador.
Que estemos usando.
Es correcto.
No nos va a correr. Nos va a mandar un error.
Porque dice que necesita un.
Un.
Procesador de tipo ARM.
Para correr. Vale.
Entonces. Ahí.
Lo que quería.
De alguna manera.
Mostrar.
Que de alguna manera.
Nos deja crear imágenes.
Para otros entornos.
Para otros tipos de procesadores.
Desde donde estemos trabajando.
Que no necesitamos.
Tener una máquina virtual.
O una máquina física.
Con ese tipo de procesador.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Que no es tan fácil.
Las redes.
Bueno.
Hace un momento levantamos un
Contenedor.
Y nos comunicamos con él.
Porque era una aplicación de tipo web.
Y nos comunicamos a puerto 80.
Y nos contestó.
En Docker. Pues obviamente.
Vamos a utilizar las redes.
Como una de las maneras.
Para poder acceder a los servicios.
Y a las aplicaciones que nosotros.
Empaquetamos. Que nosotros construimos.
Perdón.
Y para esto. Gracias. Gracias.
Para esto Docker nos proporciona.
Tres tipos de redes.
Que son.
Los tipos de red.
Bridge.
Los tipos de red puente.
La de host.
Y la de superposición.
Vale.
La de bridge. O la de puente.
Es una red predeterminada.
Porque lo que genera.
Es que cada contenedor.
Se conecta a esta red puente.
Que tiene su propia interfaz de red.
Sus frutas estáticas.
Etcétera. Etcétera.
Y que de esta manera.
Quede precisamente.
Una comunicación entre.
Puede ser puente con nuestra.
Red.
Del host.
O una red.
Que digamos. Nateada.
Para comunicar.
Exclusivamente.
El.
Contenedor.
Con nuestra máquina.
Y que podamos acceder a los servicios.
A través de esta red.
En el tema de la red host.
Lo que va a pasar es que no vamos a generar.
Ninguna red.
Sino que lo que vamos a hacer es.
Le vamos a casi casi decir.
Que la interfaz de red que tiene asignada.
Y que es la red.
Física.
Y al final.
Todos los host.
Que perdón.
Todos los puertos que vamos a abrir.
Se van a compartir.
Con nuestra máquina base.
No le podemos asignar.
Una IP.
De nuestra red.
Física.
Que está conectada a nuestra máquina base.
No es que vamos.
Física.
Y que se la vayamos a poder pasar directamente.
Al contenedor.
Simplemente va a tomar como base.
Que la IP propia.
De nuestra máquina.
Y a partir de ahí todos los puertos que abramos.
Van a contestar.
Las peticiones.
Cuando lleguen a la IP de nuestra máquina.
Sale.
Entonces de esta manera.
Fue la que hicimos hace un momento.
Lo que agarramos fue abrir un puerto.
Y el puerto 80.
Y en automático sabe que.
Si no le indicamos explícitamente.
Que tipo de red va a usar.
Estamos hablando de una red de tipo host.
Y que le queme.
Lo que vamos a hacer es abrir el puerto 80.
Vamos a compartir el puerto 80.
De nuestro contenedor.
Con nuestra máquina base.
Y una vez que tecleamos la IP de nuestra máquina base.
En el puerto en el que.
Hemos compartido con él.
Con el contenedor.
Y vamos a contestar.
A esto generalmente nosotros le conocemos como.
Forwarding.
En este caso es un forwarding.
De nuestra máquina hacia el contenedor.
Sale.
Y el tercer tipo de red.
Pues básicamente es donde.
Vamos a crear.
Una.
Igual una VLAN.
Pues que puede ahí ya.
Empezamos a generar.
Espacios específicos.
Para nuestras aplicaciones.
Y que también podemos ir separando.
De acuerdo a nuestras necesidades.
Con respecto a la organización.
De como queremos que corran.
Nuestros contenedores.
Ahí ya podemos ir creando.
Precisamente.
El tema de.
Una VLAN propia.
Que.
Nos va a permitir.
Comunicarlos.
Entre sí.
Y otras aplicaciones.
Que tenemos distribuidas.
Y.
Pues aquí por ejemplo.
Tenemos algunas opciones.
De lo que va a ser.
El tema de asignar.
Estas redes a los contenedores.
Vamos a tener aquí como ven.
El comando Docker.
En este caso el create.
Es para crear el tipo de red.
Que vamos a poner el driver.
El driver.
Y vamos a tener los que comentamos.
Hace un rato.
El overlay.
O el tipo.
Bridge.
Y vamos a tener opciones.
Como marcar la subnet.
Vamos a poder especificar el rango de direcciones.
Yps.
El gateway por ejemplo.
Que queremos que se use.
El modo de asignación de las ips.
Por ejemplo puede ser default.
Que puede ser el DHCP.
La IP del host.
Que tenga la misma.
La misma interfaz de red que el host.
Y usar la IP.
Del mismo rango.
Ninguna.
O podemos personalizar alguna.
Podemos ponerle ahí la IP estática.
Que nosotros queramos.
A nuestro contenedor.
Y a partir de aquí.
Pues básicamente con esto hacemos.
La gestión.
De las redes que podemos tener.
Dentro de nuestros contenedores.
En ejecución.
Y que se van a usar como una red.
Una red.
Física como las conocemos.
Hoy en día.
Entonces les comentaba.
Ahorita acabamos de.
Así como levantamos nuestra.
Nuestra aplicación.
Fue una red de tipo host.
Porque llamamos a nuestra máquina.
En un.
En este caso pusimos el.
127.0.0.
Y nuestra.
Nuestra aplicación contestó correctamente.
Aquí vamos a regresar.
Y creo que mi error fue ese.
Vamos a ver.
Vamos a ver.
Vamos a darle aquí.
Aquí dice que estamos.
Compartiendo a todo el mundo.
Nuestro puerto 80.
Y aquí.
Vamos a ver.
Por si usas.
Esta.
La aplicación.
Aquí dice que contesta.
Y le damos.
Aquí tenemos.
Aquí tenemos.
La.
Dice que contesta.
Entonces en nuestro navegador interno.
Aquí.
127.0.0.
Aquí ya está.
Nuestra aplicación hace un momento.
Recuerdan que yo lo puse afuera.
En mi navegador.
Y era aquí dentro.
La máquina virtual.
Aquí llevamos la respuesta que nosotros le pusimos.
Nuestra aplicación.
Aquí ya vimos llegar.
Este.
La respuesta.
Y también puede ser.
Con la ICOE que sacamos.
Aquí estamos utilizando.
Una red.
De tipo host.
Porque estamos accediendo.
A nuestro contenedor.
A través de la red.
De nuestra máquina base.
Por el puerto.
Así es.
Si es correcto.
Sí.
Sale.
Entonces.
Generalmente.
Vamos a utilizar.
En producción.
Las de tipo.
O las de tipo.
Las host.
No está.
La verdad es que es muy poco recomendado.
Más adelante.
Vamos a ver.
Que para toda esta parte.
Cuando lo vas a hacer productivo.
Existen herramientas.
Como lo son.
O son algunas otras.
Que nos ayudan.
A este.
Y otras otras herramientas.
Que nos permiten.
Llevar ya a producción.
De manera mucho más robusta.
Nuestras aplicaciones.
Es decir.
Un docker así.
Pelón.
La verdad.
Es que no se usa.
Ya cuando estás.
En aplicaciones.
Dentro de docker.
Hay una.
Hay una.
Funcionalidad.
Que se llama docker compose.
Que es la.
Digamos la más sencilla que tú vas a poder.
Usar para.
Empezar a montar servicios.
De manera productiva.
Y de esta manera.
Pues.
Es un simil sencillo.
De lo que es Kubernetes.
Pero aquí ya vas a poder.
Especificar ciertas.
Situaciones dentro.
Que quieres que hagan los contenedores.
Que este.
Que se ejecuten con ciertos.
Volumes.
Que se crean para guardar por ejemplo.
El directorio de datos.
De una base de datos.
O sea ya puedes ir especificando.
Cosas más avanzadas.
Hasta para el tema de la red.
Sale entonces.
La cosa.
Digamos la.
Lo mismo.
El ejemplo de la red.
Ahora.
Vamos a ver.
Las redes.
Vamos a empezar a ver.
Vamos a crear.
Una red.
Y aquí vamos a poner.
Lo que.
Lo que.
Lo que.
Ah bueno antes de eso.
Aquí por ejemplo.
Este.
Comando de Dockerlock.
Nos hace.
Ver lo que está sucediendo.
Dentro de la salida.
El STDout.
De nuestro contenedor. Que básicamente es como estar viendo los locks.
Entonces.
Docker.
Dockerlock.
Vamos a pegar aquí.
Entonces.
Dockerlocks.
Aquí nos muestra.
Lo mismo que estábamos viendo cuando hicimos el run.
Pero en tiempo de ejecución.
Ya lo vemos de manera estática.
O le podemos poner la opción.
Menos menos follow.
Y se queda escuchando.
Entonces por ejemplo si vuelvo a recargar.
Otra llamada.
Debería mostrarnos aquí.
Otra llamada.
Ya hicimos tres.
Y con eso nos ayuda a depurar.
Un poquito en las situaciones que están sucediendo.
De nuestra aplicación.
Dentro del contenedor.
Ahorita vamos a armar una red.
Docker network.
Y vamos a ponerle.
Vamos a ver.
Que sea de tipo bridge.
Y vamos a poner create.
Vamos a ponerle.
Curso.
Curso 01.
Creamos aquí la red.
Aquí tenemos.
Las redes que tenemos.
Creadas.
De inicio ya tenemos aquí.
Por ejemplo una red creada.
De tipo bridge.
Automático.
Acabamos de crear otra que se llama.
Curso 01.
Ya tenemos nuestra red host.
En la que está operando.
Nuestro contenedor.
Y aquí pues una que no tiene.
No tiene definición.
Estas son las que se generan.
Cuando instalamos Docker.
Y vamos a ver.
Vamos a ejecutar nuestra misma aplicación.
De hecho vamos a ejecutar la.
Que tenemos inicialmente.
Docker run.
Vamos a ponerle.
Hola.
Mundo 2.
Network.
Se llama curso 1.
Y nuestro contenedor.
Digo nuestra imagen.
Que baja aquí.
En el.
Que empieza a correr.
Y ya está corriendo.
Nuestro contenedor.
Vemos aquí.
Y ya tenemos.
Aquí nuestro hola mundo 2.
Si dan cuenta.
Que ya no nos dice que está.
Que está.
En nuestro propio puerto 80.
No lo estamos compartiendo.
Si no ya directamente sobre el contenedor.
Está corriendo en el puerto 80.
No hubo problemas en iniciarse.
Porque no.
Están usando los mismos recursos de red.
Y por eso la nuestra sigue corriendo.
Sale.
La que modificamos.
Ahora lo que yo voy a hacer.
Es porque.
Si es así.
Así es.
Aquí por ejemplo lo que vamos a hacer.
Es inspect.
Network.
Inspect.
Y en teoría.
Ah, ahí donde teníamos.
Lo que tenemos.
En ese.
Inspect.
Y se vuelve yo.
Es el nombre.
De la red.
Aj.
Inspect.
También no tengo mal.
Inspect.
Aquí ya nos dice.
La configuración de la red.
Si te das cuenta aquí.
Curso 01.
La creamos.
Cuando la creamos es de tipo local.
Driver is bridge.
No tiene activo IPv6.
Y la configuración.
Pues aleatoria.
Si quieres verlo así.
Donde el define.
Que va a ser la subnet 172.18.00.
Y que tiene.
Tamaño 16.
El getaway va a ser la 172.18.00.
1.
Y déjame ver en una calculadora.
De subnets.
Ahora.
Que si ustedes se la saben.
No me acuerdo cuantos equipos son.
No me acuerdo.
Si según yo si.
Eso ya es.
Si se puede configurar.
Pero no dentro de la red.
Digámoslo.
Y aquí vamos a.
Está medio feo ver como son las IPs.
Cuando esa pelito aquí.
El docker.
Vamos a ver si nos.
Hice rápido aquí.
Ah. Se le loco.
La 172.18.00.
0.2
Entonces.
Aquí le damos el pin.
Y hay comunicación.
Sale.
Ahorita con el comando del docker.
Le pase el ID del.
Contenedor.
Busqué.
El inicio de nuestra network.
Que es la 172.
Y aquí me aparece que tiene esta IP.
Nuestro contenedor sale.
Entonces siguiente punto.
Esta red está creada.
Y tiene comunicación entre el interior.
Digamos de esa red.
Y nuestra máquina.
Aquí por ejemplo.
Ya dejó de contestar.
Porque resulta que le di control C.
Sale entonces ahora.
Tengo que dar.
Docker.
Docker start.
Y era.
Curso 0.1.
Ah no era.
La mundo. Perdón.
La mundo.
2.
Ahí está.
A través.
Docker PSO.
Aquí ya está corriendo.
Nuestro hola mundo.
Aquí ya contestó.
Estaba apagado.
Aquí ya está encendido.
No cambio el IP.
Y.
Pues como no le especificamos.
El tipo de asignación.
Debe ser de HCP.
Y el cuanto dure la asignación.
La verdad no me acuerdo.
La verdad es que.
Generalmente hasta que eliminas el.
Contenedor.
Liberas el IP.
Por ahorita.
Como no lo hemos eliminado.
Sigue contestando.
Vamos a ver.
Si nos contesta en el puerto 80.
Venimos.
Venimos acá.
Le vamos a dar.
Aquí.
Puerto.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.
No.

on 2024-02-26

Visit the Docker y Kubernetes course recordings page

4 videos