Hola a todos.
Y bienvenidos de nuevo.
Ahora, en el video anterior, tuvimos una gran introducción al motor de orquestación de contenedores.
Ahora, ya habíamos discutido que hay múltiples motores de orquestación.
Así que tienes Docker swarm, tienes Apache missiles, tienes Kubernetes, y tienes varios otros.
Hasta ahora, Kubernetes es uno de los motores de orquestación de contenedores más populares.
Y en el vídeo de hoy, vamos a tener una introducción de alto nivel a Kubernetes, seguido de ciertas demostraciones
cortas también.
Kubernetes es un motor de orquestación de contenedores de código abierto desarrollado por Google.
Así que Kubernetes fue completamente desarrollado y mantenido por Google, y más tarde pasó a manos de
la C y ZF, que es la Cloud Native Computing Foundation, que lo gestiona actualmente.
Así que Kubernetes también se conoce como k8s en forma abreviada.
Así que la razón por la que tienes k8s es porque entre K y entre S, tienes ocho caracteres aquí.
Y esta es la razón por la que se la conoce como la K.
Ahora se habla de la arquitectura de Kubernetes.
Tienes un maestro Kubernetes aquí y tienes los nodos trabajadores.
Los nodos trabajadores son básicamente los servidores físicos o las máquinas virtuales donde se ejecutarán los
contenedores.
Y el maestro Kubernetes es el que gestionará los contenedores.
Así que el maestro Kubernetes básicamente recibirá los comandos de los usuarios.
Ahora, la pregunta es: ¿cómo recibirá las órdenes?
Así que puede recibir los comandos vía API, puede recibirlos vía CLI, y también puede recibirlos vía UI.
Así que tienes la API CLA y GI a través de la cual los usuarios podrán enviar los comandos al maestro Kubernetes y el maestro
Kubernetes procesará las cosas que se mencionan dentro de los comandos.
Entendámoslo con una simple analogía.
Así que digamos que usted tiene un comando llamado como quiero lanzar App A.
Así que este es el comando que le das a Kubernetes, maestro.
Así que ahora Kubernetes maestro comprobará que el número de nodos que tiene.
Así que actualmente hay tres nodos que están asociados con el maestro Kubernetes.
Así que seguirá adelante y lanzará la aplicación en uno de los nodos.
Ahora bien, hay varios algoritmos en función de los cuales se selecciona un nodo específico, por lo que no
es que ese nodo A tenga actualmente el 100% de la carga de la CPU.
Así que en ese caso, el maestro Kubernetes no enviará realmente la aplicación a Nodo uno.
Lo enviará al nodo que tenga más recursos disponibles.
Hay muchas cosas que ocurren entre bastidores, pero de momento sólo tenemos una
visión general de alto nivel.
De acuerdo.
Así que actualmente tiene el comando que ha sido suministrado por el usuario Kubernetes es maestro lo tomó
y lanzó el contenedor en uno de los nodos trabajadores.
Ahora, digamos que por alguna razón este nodo trabajador ha dejado de funcionar.
Puede haber una razón por la que el servidor dejó de funcionar debido a un problema de energía, conectividad de red, problema
del kernel, y varios otros.
Así que ahora, una vez que este nodo trabajador haya dejado de funcionar, el maestro Kubernetes lo detectará automáticamente.
Así que detecta automáticamente que el nodo trabajador no está funcionando realmente bien y migra el contenedor
a un nodo trabajador diferente en ejecución.
También se le denomina registro de intenciones.
Así que lo que el registro de intenciones es básicamente Así que este es el registro de intenciones en una visión general de alto nivel.
Así que el registro de la intención es generalmente dada por el usuario, que establece que quiero lanzar app un contenedor.
Así que este es el contenedor de aplicaciones.
Y como usuario le digo al OC de Kubernetes, quiero lanzar el contenedor de la aplicación, y eso es todo.
Ahora no tengo que hacer nada más.
Kubernetes se encargará tanto de lanzar el contenedor como de gestionarlo a largo plazo.
Así que, como estábamos discutiendo, no se trata sólo de lanzar el contenedor una vez.
También se trata del chequeo médico.
Kubernetes master no sólo puede detectar que el nodo está caído, también puede detectar si la aplicación no funciona correctamente.
Y si el contenedor de aplicaciones no funciona correctamente, puede reiniciarlo automáticamente.
Puede migrar automáticamente el contenedor de la aplicación a diferentes nodos de trabajo y varios otros.
Así que hay muchas cosas que suceden entre bastidores.
Así que en el vídeo de hoy nos hemos centrado en la introducción.
Así que sólo estamos viendo una visión general de alto nivel sobre cómo funcionan las cosas.
Así que vamos a pasar rápidamente a la demo para que entendamos más sobre ella.
Así que estoy en mi clase y vamos a hacer rápidamente un cubo.
Obtener nodos.
Y actualmente ves que tengo un nodo que está disponible.
Así que estábamos discutiendo durante la fase de arquitectura que tiene un maestro Kubernetes y luego tiene
múltiples nodos de trabajo.
Así que los nodos trabajadores son básicamente donde se desplegarían los contenedores.
Así que los nodos trabajadores pueden ser uno, pueden ser 100, incluso pueden ser 1000.
Así que realmente depende.
Así que para nuestra demostración, tenemos un nodo trabajador, que está actualmente disponible.
Ahora, en la siguiente diapositiva, estábamos discutiendo sobre el registro de intención, donde a través de uno
de los medios puede ser API claro, suministramos un registro de intención.
Así que el registro de la intención era que quiero lanzar app un contenedor, así que vamos a probarlo.
Así que diré que se ejecute, lo llamaré como Motor X y lo lanzaré desde la imagen del motor X.
Ahora no tienes que preocuparte de cuáles son estos comandos.
En el próximo vídeo hablaremos de ello con todo detalle.
Este vídeo en concreto es solo para darte una idea general sobre Kubernetes.
Así que una vez que ejecute esto, dice que el motor de despliegue se crea.
Y ahora si haces un cubo, tendrá puertos.
Verá que tiene un pod que está en fase de creación.
¿Qué ocurrió exactamente?
Le dijimos a Kubernetes es que queremos lanzar un contenedor desde la imagen del motor X.
Así que esta es la parte que habíamos hecho, y esto fue suministrado al maestro Kubernetes.
Ahora, el maestro Kubernetes buscará en los nodos trabajadores y luego lanzará ese pod específico en uno de los nodos
trabajadores.
Así que usted puede referirse vaina como un contenedor para empezar.
Así que Kubernetes básicamente ha lanzado el contenedor en uno de los nodos trabajadores.
Así que ahora, si actualizas, verás que el estado de esta placa actual está en estado de ejecución.
Así que ahora este pod se está ejecutando actualmente en mi servidor donde estamos ejecutando los comandos CLI.
Así que si hago una pieza Docker en el motor X, de hecho, permítanme copiar este nombre.
Verás que tienes un contenedor de motor que está en marcha.
Así que ahora vamos a hacer una cosa.
Detengamos este contenedor y veamos qué ocurre exactamente.
Así que voy a decir, Docker, para.
Seguido del contenedor.
Y ahora si haces una pieza Docker, deberías ver que el primer contenedor que habíamos parado, ya
no está presente por aquí.
Así que ahora mirando en la arquitectura.
Así que lo que habíamos hecho, le dijimos a Kubernetes que lanzara un contenedor desde la imagen del motor X.
Kubernetes se adelantó y creó el contenedor.
Así que ahora lo que hicimos, en lugar de eliminar el nodo, lo que hicimos, manualmente nos detuvimos el contenedor.
O puedes decir que matamos al contenedor.
Así que ahora Kubernetes será capaz de detectar que este contenedor ya no está funcionando y puede iniciarlo automáticamente
o puede iniciar automáticamente un nuevo contenedor en un nodo diferente por completo.
Así que si quieres ver de nuevo, vamos a hacer una pieza Docker y verás que un contenedor más se puso en marcha.
Así que este contenedor fue lanzado antes de 53 segundos.
Así que esta es una de las grandes características de un motor orquestador típico, que es Kubernetes en nuestro caso.
Así que espero que a un alto nivel, todos ustedes entendieron lo que es Kubernetes.
Ahora, de nuevo, este es sólo uno de los ejemplos que habíamos tomado.
Ahora, Kubernetes tiene un montón de características, y vamos a discutir acerca de ellos a medida que avanzamos a lo largo
del curso.
Ahora, antes de concluir este video, sólo quería mostrarte una cosa más.
Así que estábamos discutiendo que había tres maneras en que usted puede suministrar los comandos a Kubernetes.
Maestro, tienes la API, tienes la ClA, y tienes la UI.
Así que el comando CTL que estábamos ejecutando en esta demo era un ejemplo de CLI.
También tienes la función de IU.
Así que si quieres ver cómo se ve exactamente Java, este es el panel de control de interfaz de usuario para Kubernetes.
Así que si usted ve aquí dentro de los nodos, que está mostrando que hay un nodo trabajador que está
disponible.
También muestra la CPU, así como las especificaciones relacionadas con la memoria de ese nodo trabajador específico.
Ahora, junto con eso, también puede mostrarle diversa información sobre los contenedores actuales
que están ejecutando los conjuntos de demonios, despliegues, etc. Así que esta es una gran IG que está disponible y realmente ayuda
a entender las cosas de una manera más rápida porque la interfaz de usuario es siempre la forma rápida de demostrar las cosas.
Así que este es el IG.
También habíamos mirado en la CLI y definitivamente incluso se puede suministrar comandos a través de la API.
Este es el resumen de alto nivel sobre Kubernetes.
De nuevo, en el vídeo de hoy hemos tenido una visión general de muy alto nivel.
Espero que tengas una idea general de lo que es Kubernetes y cuáles son las cosas que puede hacer.
Ahora, en los próximos vídeos, vamos a entrar en detalle acerca de Kubernetes, y vamos a ver en un montón
de características que el motor orquestador Kubernetes proporciona.
Con esto concluiremos este vídeo.
Espero que este vídeo le haya resultado informativo y le espero en el próximo.