Kubernetes es parte de un proyecto de código abierto que ayuda a administrar un clúster de contenedores como un solo sistema. También es una herramienta importante que administra y ejecuta contenedores Docker en múltiples hosts al tiempo que ofrece la ubicación de estos contenedores.
Durante una década, Google se ha beneficiado de la tecnología de contenedores. Con Kubernetes, es más fácil para Google compartir su experiencia en aplicaciones en contenedores y crear una plataforma abierta para ejecutar varios contenedores a gran escala.
En este artículo, lo guiaremos a través de varios pasos para ayudarlo a construir, implementar y administrar Docker en Kubernetes.
requisito
Para completar este proceso necesitará:
- Una cuenta de Docker activa para guardar la imagen
- Un clúster de Kubernetes
- Servidor web o aplicación, en nuestro caso una aplicación de “lista de tareas pendientes” que utiliza una base de datos MongoDB.
- La aplicación Git está completamente instalada en su computadora.
¿Cómo funciona Kubernetes?
Las instancias de Kubernetes se conocen como clústeres (es decir, servidores maestros y varios minions). El maestro administra los minions que utilizan las herramientas de comando para conectarse al punto final de la API. El host de Docker recibe la señal de los servidores maestros para ejecutar los contenedores.
El clúster de Kubernetes contiene varias unidades:
- Maestro: conecta todos los componentes del nodo para que funcionen como una unidad.
- Pods: una colección de unidades que ejecutan uno o más contenedores.
- Minion: parte de los múltiples hosts de Docker que reciben instrucciones del maestro sobre cómo administrar y ejecutar contenedores.
- Los componentes de nodo están asociados con pods específicos y pueden ser máquinas físicas o virtuales.
Paso 1: crea una imagen con Dockers
El primer paso es contener el servidor web o la aplicación creando una imagen para Dockers. Visite su página de inicio y luego use Git, modifique la aplicación web del tutorial en la página del repositorio en GitHub.
$ cd ~ $ git clone https://github.com/janakiramm/todo-app.git
Comience compilando la imagen a partir de su archivo Docker. Inserte el nombre de usuario, el nombre de la imagen y una etiqueta (opcional) con la ayuda de t-switch.
$docker build -t sammy/todo
Si la imagen se creó correctamente, debería ver un resultado como este:
Sending build context to Docker daemon 8.238MB Step 1/7 : FROM node:slim ---> 286b1e0e7d3f Step 2/7 : LABEL maintainer = "jani@janakiram.com" ---> Using cache ---> ab0e049cf6f8 Step 3/7 : RUN mkdir -p /usr/src/app ---> Using cache ---> 897176832f4d Step 4/7 : WORKDIR /usr/src/app ---> Using cache ---> 3670f0147bed Step 5/7 : COPY ./app/ ./ ---> Using cache ---> e28c7c1be1a0 Step 6/7 : RUN npm install ---> Using cache ---> 7ce5b1d0aa65 Step 7/7 : CMD node app.js ---> Using cache ---> 2cef2238de24 Successfully built 2cef2238de24 Successfully tagged sammy/todo-app:latest
Asegúrese de que la imagen fue creada ingresando el siguiente comando:
$ docker images
Guarde la imagen en Docker Hub en el directorio público iniciando sesión en su cuenta de Hub en Dockers:
$ docker login
Ingrese su información de inicio de sesión. En este caso, use un nombre de usuario único para identificar su imagen en Dockerfile.
$ docker tag your_docker_hub_username/todo-app
Transfiera la imagen a Docker Hub:
$ docker push
Una vez que tenga la imagen de Docker en el registro, puede continuar con la configuración de la aplicación Kubernetes.
Paso 2: Implementar Pod (MongoDB) en Kubernetes
Esta aplicación utiliza una base de datos MongoDB para garantizar el almacenamiento seguro de Listas de tareas pendientes que se crean en el servidor web / aplicación. Para implementar correctamente MongoDB en Kubernetes, debe ejecutarlo como un pod.
Empiece por crear un archivo YAML, comúnmente conocido como db-pod.yamI:
$ nano db-pod.yaml
Pegue el puerto predeterminado que define su pod en MongoDB. Esto debe incluir el nombre y la aplicación. Se utilizan para configurar pods.
db-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: db
labels:
name: mongo
app: todoapp
spec:
containers:
- image: mongo
name: mongo
ports:
- name: mongo
containerPort: 27017
volumeMounts:
- name: mongo-storage
mountPath: /data/db
volumes:
- name: mongo-storage
hostPath:
path: /data/dbA continuación, ejecute el siguiente comando para crear su pod
$ kubectl create -f db-pod.yml
Asegúrese de obtener el siguiente resultado:
$ pod "db" created
Verifique que el pod se esté ejecutando con el siguiente comando:
$ kubectl get pods
La siguiente figura muestra que el pod se ejecuta correctamente:
NAME READY STATUS RESTARTS AGE db 1/1 Running 0 2m
Para que el pod esté disponible para los clientes de los clústeres, cree un archivo llamado db-service.yaml que contiene el código que representa MongoDB.
db-service.yaml
apiVersion: v1
kind: Service
metadata:
name: db
labels:
name: mongo
app: todoapp
spec:
selector:
name: mongo
type: ClusterIP
ports:
- name: db
port: 27017
targetPort: 27017Guarde su archivo y use el comando kubectl para transmitir el resultado al clúster del sistema:
$ kubectl create -f db-service.yml
Debería tener algo como esto como salida:
$ service "db" created
Para saber qué puerto muestra el pod exacto que está utilizando, ejecute el siguiente comando:
$ kubectl get services
La salida debería verse así:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE db ClusterIP 10.109.114.243 <none> 27017/TCP 14s kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 47m
En este ejemplo, notará que el pod de servicio que creó aparece en el puerto 27017, que es el puerto predeterminado que usa MongoDB. Por lo tanto, la aplicación web puede llegar fácilmente a este servicio con los resultados anteriores. Este proceso facilita que los pods se identifiquen y se conecten entre sí.
Paso 3: escalar la aplicación web
Escalar los servicios web con conjuntos de réplicas es un proceso para garantizar que la cantidad de pods converja en todas partes. Al empaquetar el pod como un conjunto de réplicas, Kubernetes puede ejecutar la menor cantidad de pods implementados.
Necesitamos eliminar el pod existente y crear un nuevo conjunto para el conjunto de réplicas.
Ejecute el siguiente comando para eliminar el pod actual:
$ kubectl delete pod web
La salida debería verse así:
pod "web" deleted
Continúe con la creación de un nuevo conjunto de réplicas.
Empiece a crear el archivo web-rs.yaml luego agregue el siguiente código:
apiVersion: extensions/v1beta1
kind: ReplicaSet
metadata:
name: web
labels:
name: web
app: todoapp
spec:
replicas: 2
template:
metadata:
labels:
name: web
spec:
containers:
- name: web
image: sammy/todo-app
ports:
- containerPort: 3000Ahora guarda y sal.
Continúe y cree su conjunto de réplicas como se muestra a continuación:
$ kubectl create -f web-rs.yaml
La salida debería verse así:
replicaset "web" created
Verifique la cantidad exacta de pods creados:
$ kubectl get pods NAME READY STATUS RESTARTS AGE db 1/1 Running 0 18m web-n5l5h 1/1 Running 0 25s web-wh6nf 1/1 Running 0 25s
Pruebe que el conjunto de réplicas esté funcionando. Para hacer esto, elimine uno de sus pods y observe lo que sucede:
$ kubectl delete pod web-wh6nf
La salida debe contener el siguiente texto:
pod "web-wh6nf" deleted
Verifique las cápsulas para confirmar que estén funcionando:
kubectl get pods
producción
NAME READY STATUS RESTARTS AGE db 1/1 Running 0 19m web-n5l5h 1/1 Running 0 1m web-wh6nf 1/1 Terminating 0 1m web-ws59m 0/1 ContainerCreating 0 2s
Cuando se elimina un pod, Kubernetes crea otro conjunto para reemplazarlo y continuar con el proceso.
Ejecute el siguiente comando para escalar su conjunto de réplicas a más pods web, por ejemplo 7,
$ kubectl scale rs/web --replicas=7
producción
replicaset "web" scaled
Verifique la cantidad de vainas
$ kubectl get pods
La salida debería verse así:
Output NAME READY STATUS RESTARTS AGE db 1/1 Running 0 22m web-4nh4g 1/1 Running 0 21s web-7vbb5 1/1 Running 0 21s web-8zd55 1/1 Running 0 21s web-f8hvq 0/1 ContainerCreating 0 21s web-ffrt6 1/1 Running 0 21s web-k6zv7 0/1 ContainerCreating 0 21s web-n5l5h 1/1 Running 0 3m web-qmdxn 1/1 Running 0 21s web-vc45m 1/1 Running 0 21s web-ws59m 1/1 Running 0 2m
Kubernetes ahora ha comenzado a escalar el pod de aplicaciones web. Una vez que el servicio esté activo, se enrutará a un pod específico en su conjunto de réplicas.
Cuando la carga disminuye, puede restablecer el servicio al estado inicial de dos pods con el siguiente comando:
kubectl scale rs/web --replicas=2
producción
replicaset "web" scaled
Para terminar el resto de los pods excepto los dos, ejecute el siguiente comando:
$ kubectl get pods
Debería tener la siguiente salida:
producción
NAME READY STATUS RESTARTS AGE db 1/1 Running 0 24m web-4nh4g 1/1 Terminating 0 2m web-7vbb5 1/1 Terminating 0 2m web-8zd55 1/1 Terminating 0 2m web-f8hvq 1/1 Terminating 0 2m web-ffrt6 1/1 Terminating 0 2m web-k6zv7 1/1 Terminating 0 2m web-n5l5h 1/1 Running 0 5m web-qmdxn 1/1 Terminating 0 2m web-vc45m 1/1 Terminating 0 2m web-ws59m 1/1 Running 0 4m
Compruebe si el conjunto de réplicas está disponible intentando eliminar uno de sus pods en el servicio:
$ kubectl delete pod web-ws59m
La salida debería verse así:
Output pod "web-ws59m" deleted $ kubectl get pods
producción
NAME READY STATUS RESTARTS AGE db 1/1 Running 0 25m web-n5l5h 1/1 Running 0 7m web-ws59m 1/1 Terminating 0 5m web-z6r2g 0/1 ContainerCreating 0 5s
Cuando cambia el número de pods, Kubernetes se ajusta para coincidir con el número específico de pods en el archivo YAML.
Ejecute el siguiente comando para eliminar alguno o todos los elementos de esta guía:
$ kubectl delete -f db-pod.yaml -f db-service.yaml -f web-rs.yaml -f web-service.yaml
La salida debería verse así:
Output pod "db" deleted service "db" deleted replicaset "web" deleted service "web" deleted
Conclusión
Si sigue esta guía paso a paso, debería poder implementar y escalar Docker con Kubernetes. Esperamos que esta guía haya ayudado a que eso suceda.
Si desea obtener más información sobre Kubernetes, consulte la guía de Hosting Más Barato para el alojamiento de Kubernetes.
