Instalación de Dockers y Kubernetes en Linux Centos

Share on facebook
Share on twitter
Share on linkedin
Share on whatsapp
Share on telegram
Share on email

¿Qué son los contenedores?

Los Dockers o Contenedores son una capa de virtualización a nivel de software y no de todo el sistema operativo, tal y como ocurre en la virtualización tradicional como la de VMWare, por ejemplo.

Esto significa que podemos «empaquetar» una aplicación de Tomcat 6 en un contenedor y otra aplicación de Tomcat 7 en otro contenedor diferente, ambos corriendo en el mismo servidor físico.

Los contenedores se encargan de utilizar todos los recursos necesarios del Host físico, tal y como puede ser el kernel del sistema operativo o librerías, por ejemplo.

La idea de virtualización de las aplicaciones es disminuir el número de servidores físicos o virtuales conservando o mejorando su rendimiento y minimizando el número de sistemas operativos a administrar.

Con Dockers también podemos virtualizar otros elementos hardware como, una red aislada para cada aplicación.

Instalando Dockers en Linux Centos 7

Estoy probando Dockers en un Centos 7.5, concretamente en esta versión:

[[email protected] ~]# lsb_release -a
 LSB Version: :core-4.1-amd64:core-4.1-noarch
 Distributor ID: CentOS
 Description: CentOS Linux release 7.5.1804 (Core) 
 Release: 7.5.1804
 Codename: Core
 [[email protected] ~]#

Lo primero que he hecho ha sido instalar el producto con el comando yum install docker. Para ello, he tenido que habilitar el repositorio Centos-Extras, añadiendo la directiva enabled=1 en el fichero /etc/yum.repos.d/CentOS-Base.repo.

[[email protected] ~]# rpm -qa |grep -i docker
 docker-common-1.13.1-75.git8633870.el7.centos.x86_64
 docker-client-1.13.1-75.git8633870.el7.centos.x86_64
 docker-1.13.1-75.git8633870.el7.centos.x86_64
 [[email protected] ~]#

A continuación, he habilitado y arrancado el servicio:

[[email protected] ~]# systemctl enable docker
 Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
[[email protected] ~]#

[[email protected] ~]# systemctl start docker
[[email protected] ~]#

 [[email protected] ~]# systemctl status docker
 ● docker.service - Docker Application Container Engine
 Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
 Active: active (running) since Wed 2018-10-31 12:18:48 CET; 4s ago
 Docs: http://docs.docker.com
 Main PID: 3481 (dockerd-current)
 Tasks: 17
 CGroup: /system.slice/docker.service
 ├─3481 /usr/bin/dockerd-current --add-runtime docker-runc=/usr/libexec/do...
 └─3486 /usr/bin/docker-containerd-current -l unix:///var/run/docker/libco...
Oct 31 12:18:47 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:47.776905246+..."
 Oct 31 12:18:47 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:47.817330457+..."
 Oct 31 12:18:47 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:47.818285710+..."
 Oct 31 12:18:47 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:47.838045198+..."
 Oct 31 12:18:48 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:48.065625910+..."
 Oct 31 12:18:48 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:48.258164231+..."
 Oct 31 12:18:48 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:48.304388542+..."
 Oct 31 12:18:48 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:48.304428927+...1
 Oct 31 12:18:48 Centos7 dockerd-current[3481]: time="2018-10-31T12:18:48.317518495+..."
 Oct 31 12:18:48 Centos7 systemd[1]: Started Docker Application Container Engine.
 Hint: Some lines were ellipsized, use -l to show in full.
 [[email protected] ~]#

Arrancando nuestro primer contenedor

Con el comando docker search «Nombre_del_contenedor» podemos encontrar todos los contenedores disponibles en el repositorio oficial de DockerHub.

O también los podemos encontrar vía WEB:

Búsqueda de un contenedor en DockerHub

Imaginemos que nos interesa instalar el contenedor llamado «httpd». Lo haremos con el siguiente comando docker pull httpd:

Y comprobamos que hemos descargado la imagen del contenedor correctamente con el comando docker images:

Por fin llegamos al punto clave de esta sección: Arrancar el contenedor. Lo haremos con el comando docker run -dit –name apachetest -p 8080:80 -v /tmp/ws/:/usr/local/apache2/htdocs/ httpd.

Lo que estamos haciendo aquí es:

  • El nombre del contenedor será apachetest.
  • Mapeamos el puerto local 8080 hacia el puerto 80 interno del contenedor.
  • Mapeamos el directorio local /tmp/ws al directorio interno del contenedor /usr/local/apache2/htdocs, que es el DocumentRoot del servidor de Apache del contenedor.

También voy a crear un fichero local que será cargado por el servidor de Apache del contenedor:

[[email protected] ~]# cat /tmp/ws/index.html 
 <html>
 Soy un Webserver corriendo en un contenedor
 </html>
 [[email protected] ~]#

Con el comando docker ps comprobaremos todos los contenedores que tenemos en ejecución:

Con el comando docker inspect ID, por ejemplo docker inspect 9b74aaddb3fd obtendremos mucha infomación interna del contenedor que no pondré aquí porque es demasiada. Dejo que lo probéis vosotros.

Eliminar un contenedor

Para finalizar, vamos a eliminar el contenedor que hemos creado.

Primeramente lo pararemos con el comando docker stop.

Ahora ya lo podemos eliminar con el comando docker rm ID.

Eliminar la imagen de un contenedor

Si no vamos a arrancar más contenedores basados en la misma imagen del contenedor, la eliminaremos con el comando docker rmi ID.

Alta disponibilidad con Kubernetes

Si vamos a trabajar en entornos profesionales, necesitamos configurar el servicio con alta disponibilidad para que los usuarios finales no se vean afectados en caso de incidencia con alguno de los nodos. Esto lo vamos a conseguir con Kubernetes.

Conceptos básicos de Kubernetes

Kuberntes es un sistema de clusters de contenedores de código abierto desarrollado por Google. Básicamente, configuraremos la cantidad de contenedores que queremos que se ejecuten simultáneamente y en cuántos nodos.

  • Pod: Es el conjunto de contenedores y volúmenes.
  • Replication controllers: Es el gestor de Pods que vigila en todo momento cuántos Pods hay levantados y en qué nodos. En caso de incidencia en alguno de los nodos, se encarga de replicar el Pod en otro para asegurar de que tenemos levantados tantos Pods como hemos definido en la configuración del cluster.
  • Service: Define cómo acceder al conjunto de Pods.

Componentes del Master

El Master es el componente al que todos los nodos del cluster se comunican. Digamos que es el organizador del cluster.

  • etcd: Es el servicio más importante del cluster, ya que almacena toda la información del cluster en formato clave-valor.
  • Kube-ApiServer: Por motivos de seguridad, es el único componente que puede conectarse al servicio etcd mediante el intercambio de claves. Si alguien consiguiera acceder a ApiServer, se haría con el control de todo el cluster.
  • Kube-Controller: Vigila el estado de todos los componentes del cluster.
  • Scheduler: Organiza la distribución de los Pods dentro del cluster.

Componentes de los nodos

  • Kubelet: Es el proceso que corre en cada nodo para comunicarse con el master.
  • CAdvisor: Se encarga de recoger estadísticas de rendimiento de los contenedores (dockers).
  • Kube-proxy: Es una interfaz de red que se utiliza para la comunicación entre los diferentes contenedores.
  • POD: Comentado anteriormente. Es un conjunto de contenedores.

Instalación de Kubernetes en CentOS 7

En CentOs 7, instalaremos Kubernetes con el siguiente comando:

yum install -y kubernetes etcd

Para que funcione, deberemos tener habilitado el repositorio Centos-Extras.

Una vez instalados los paquetes ya podemos comenzar a arrancar servicios.

Arranque de servicios en el Master

systemctl start etcd
systemctl start kube-controller-manager
systemctl start kube-scheduler
systemctl start kube-apiserver

Arranque de los servicios en cada uno de los nodos

systemctl start docker
systemctl start kube-proxy
systemctl start kubelet

Al arrancar los servicios, observaremos que se ha creado una interfaz de red nueva llamada docker0.

Configuración del POD

Crearemos un fichero en formato JSON como el que viene a continuación. Si os acordáis,  en el artículo Instalación y configuración de Dockers (Contenedores) en Centos 7 ya nos descargamos el contenedor de Apache, así que lo aprovecharemos para configurar el POD.

Esta vez, lo arrancaré en el puerto 9090 local, ya que por el 8080 tengo otro servicio escuchando:

[[email protected] kubernetes]# docker run -dit --name apachetest -p 9090:80 -v /tmp/ws/:/usr/local/apache2/htdocs/ httpd
7983a74eee23fa59abd434ad5107896e2b2a1a5b9539c5770e6d1c8549eeb060
[[email protected] kubernetes]#

[[email protected] kubernetes]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7983a74eee23 httpd "httpd-foreground" About a minute ago Up About a minute 0.0.0.0:9090->80/tcp apachetest
[[email protected] kubernetes]#

[[email protected] kubernetes]# curl -s http://localhost:9090
<html>
<body>
Soy un contenedor
</body>
</html>
[[email protected] kubernetes]#

El fichero JSON sería el siguiente:

[[email protected] kubernetes]# cat container-httpd-rc.json
{ "kind":"ReplicationController",
"apiVersion":"v1",
"metadata":{ "name":"apachepod-controller" },
"spec":{
"replicas":3,
"selector":{ "name":"apachepod" },
"template":{
"metadata":{
"labels":{ "name":"apachepod" }
},
"spec":{
"containers":[ {
"name":"apachepod",
"image":"docker.io/httpd",
"ports":[ {
"containerPort":80,
"protocol":"TCP"
} ]
} ]
}
}
}
}
[[email protected] kubernetes]#


A continuación, aplicamos la configuración:

  • Si no hemos creado previamente una clave, la tendemos que crear por primera vez:
[[email protected] kubernetes]# openssl genrsa -out /tmp/serviceaccount.key 2048
Generating RSA private key, 2048 bit long modulus
............................+++
............................................................+++
e is 65537 (0x10001)

Editamos el fichero /etc/kubernetes/apiserver, añadiendo:

KUBE_API_ARGS="--service_account_key_file=/tmp/serviceaccount.key"

Editamos el fichero /etc/kubernetes/controller-manager, añadiendo:

KUBE_CONTROLLER_MANAGER_ARGS="--service_account_private_key_file=/tmp/serviceaccount.key"

Reiniciamos el servicio de Kubernetes:

[[email protected] kubernetes]# systemctl restart etcd
[[email protected] kubernetes]# systemctl restart kube-controller-manager
[[email protected] kubernetes]# systemctl restart kube-scheduler
[[email protected] kubernetes]# systemctl restart kube-apiserver
[[email protected] kubernetes]#
  • Una vez generada la clave, por fin podemos crear nuestro POD a partir del fichero JSON creado previamente:
[[email protected] kubernetes]# kubectl create -f container-httpd-rc.json
replicationcontroller "apachepod-controller" created
[[email protected] kubernetes]#

[[email protected] kubernetes]# kubectl get pod
NAME READY STATUS RESTARTS AGE
apachepod-controller-10xv7 0/1 Pending 0 50s
apachepod-controller-dx8nr 0/1 Pending 0 50s
apachepod-controller-nm5k4 0/1 Pending 0 50s
[[email protected] kubernetes]#

[[email protected] kubernetes]# kubectl get replicationcontrollers
NAME DESIRED CURRENT READY AGE
apachepod-controller 3 3 0 1m
[[email protected] kubernetes]#

Si lo deseamos, podemos escalar en tiempo real el número de PODs:

[[email protected] kubernetes]# kubectl scale rc apachepod-controller --replicas=4
replicationcontroller "apachepod-controller" scaled
[[email protected] kubernetes]# kubectl get replicationcontrollers
NAME DESIRED CURRENT READY AGE
apachepod-controller 4 4 0 2m
[[email protected] kubernetes]# kubectl get pod
NAME READY STATUS RESTARTS AGE
apachepod-controller-10xv7 0/1 Pending 0 3m
apachepod-controller-dx8nr 0/1 Pending 0 3m
apachepod-controller-ksrdc 0/1 Pending 0 14s
apachepod-controller-nm5k4 0/1 Pending 0 3m
[[email protected] kubernetes]#

Creación de los nodos que van a formar parte del cluster de kubernetes:

[[email protected] kubernetes]# cat nodes.json
{
"kind": "Node",
"apiVersion": "v1",
"metadata": {
"name": "10.0.0.2",
"labels": {
"environment": "production",
"name": "kubernete1"
}
}
}

{
"kind": "Node",
"apiVersion": "v1",
"metadata": {
"name": "10.0.0.3",
"labels": {
"environment": "production",
"name": "kubernete2"
}
}
}
[[email protected] kubernetes]#

[[email protected] kubernetes]# kubectl create -f nodes.json
node "10.0.0.2" created
node "10.0.0.3" created
[[email protected] kubernetes]#

Instalación de Kubernetes en CentOS 8

La instalación de Kubernetes en Linux Centos 8 difiere un poco de Centos 7, pero es muy parecido. No obstante, vamos a ver el proceso completo.

Para este entorno he creado tres servidores virtuales, uno hace de Master y los otros dos son los Workers.

Tareas ejecutadas en los tres nodos del cluster

  • Configuración del fichero /etc/hosts en los tres nodos:
10.0.1.195 kubmaster
10.0.1.46 kubworker1
10.0.1.61 kubworker2
  • Instalación del repositorio de Dockers previo a la instalación de paquetes:
dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo

dnf install -y https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm

dnf install -y docker-ce
  • Habilitamos el servicio:
systemctl enable docker
systemctl start docker
  • Configuramos el repositorio de yum (dnf) de kubernetes:
[[email protected] ~]# cat /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
[[email protected] ~]#
  • Instalamos kubeadm:
dnf install -y kubeadm

systemctl enable kubelet
systemctl start kubelet

Tareas ejecutadas solamente en el nodo Master

  • Deshabilitamos swap, de lo contrario el comando kubeadm init, falla, dando el aviso de que el swap está habilitado:
swapoff -a

Hay que deshabilitarlo también en el /etc/fstab.

  • Generamos la estructura de kubernetes con kubeadm init e iniciamos el servicio del Master. Importante guardarse el token generado al final del proceso.
[[email protected] ~]# kubeadm init
W1201 14:32:20.815754    1151 configset.go:348] WARNING: kubeadm cannot validate component configs for API groups [kubelet.config.k8s.io kubeproxy.config.k8s.io]
[init] Using Kubernetes version: v1.19.4
[preflight] Running pre-flight checks
        [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/
        [WARNING FileExisting-tc]: tc not found in system path
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [ip-10-0-1-195.eu-west-1.compute.internal kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 10.0.1.195]
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [ip-10-0-1-195.eu-west-1.compute.internal localhost] and IPs [10.0.1.195 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [ip-10-0-1-195.eu-west-1.compute.internal localhost] and IPs [10.0.1.195 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Starting the kubelet
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
[control-plane] Creating static Pod manifest for "kube-scheduler"
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
[apiclient] All control plane components are healthy after 17.003729 seconds
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.19" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Skipping phase. Please see --upload-certs
[mark-control-plane] Marking the node ip-10-0-1-195.eu-west-1.compute.internal as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node ip-10-0-1-195.eu-west-1.compute.internal as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[bootstrap-token] Using token: hlsafr.yqsb71wbxp9q3wtt
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to get nodes
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 10.0.1.195:6443 --token hlsafr.yqsb71wbxp9q3wtt \
    --discovery-token-ca-cert-hash sha256:f2bfaccf4b0a03546f1d951e9938f062fa0fe3f382920e0a1711afbd126b3754
[[email protected] ~]#

Seguimos en el nodo Master

kubeadm join --token hlsafr.yqsb71wbxp9q3wtt --discovery-token-ca-cert-hash sha256:f2bfaccf4b0a03546f1d951e9938f062fa0fe3f382920e0a1711afbd126b3754

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config

[[email protected] ~]# kubectl get nodes
NAME                                       STATUS     ROLES    AGE     VERSION
ip-10-0-1-195.eu-west-1.compute.internal   NotReady   master   3m31s   v1.19.4
[[email protected] ~]#

Como vemos, todavía está en estado Not Ready. Todavía tenemos que crear la red de PODs en el Master.

[[email protected] ~]# kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/2140ac876ef134e0ed5af15c65e414cf26827915/Documentation/kube-flannel.yml

podsecuritypolicy.policy/psp.flannel.unprivileged created
Warning: rbac.authorization.k8s.io/v1beta1 ClusterRole is deprecated in v1.17+, unavailable in v1.22+; use rbac.authorization.k8s.io/v1 ClusterRole
clusterrole.rbac.authorization.k8s.io/flannel configured
Warning: rbac.authorization.k8s.io/v1beta1 ClusterRoleBinding is deprecated in v1.17+, unavailable in v1.22+; use rbac.authorization.k8s.io/v1 ClusterRoleBinding
clusterrolebinding.rbac.authorization.k8s.io/flannel unchanged
serviceaccount/flannel unchanged
configmap/kube-flannel-cfg configured
daemonset.apps/kube-flannel-ds-amd64 created
daemonset.apps/kube-flannel-ds-arm64 created
daemonset.apps/kube-flannel-ds-arm created
daemonset.apps/kube-flannel-ds-ppc64le created
daemonset.apps/kube-flannel-ds-s390x created
[[email protected] ~]#

[[email protected] ~]# kubectl get nodes
NAME                                       STATUS   ROLES    AGE   VERSION
ip-10-0-1-195.eu-west-1.compute.internal   Ready    master   6m    v1.19.4
[[email protected] ~]#

Ahora ya vemos el servicio en estado Ready.

Nos volvemos a conectar a los dos nodos Workers

[[email protected] ~]# kubeadm join 10.0.1.195:6443 --token hlsafr.yqsb71wbxp9q3wtt --discovery-token-ca-cert-hash sha256:f2bfaccf4b0a03546f1d951e9938f062fa0fe3f382920e0a1711afbd126b3754
[preflight] Running pre-flight checks
        [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/
        [WARNING FileExisting-tc]: tc not found in system path
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

[[email protected] ~]#


[[email protected] ~]# kubeadm join 10.0.1.195:6443 --token hlsafr.yqsb71wbxp9q3wtt --discovery-token-ca-cert-hash sha256:f2bfaccf4b0a03546f1d951e9938f062fa0fe3f382920e0a1711afbd126b3754
[preflight] Running pre-flight checks
        [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/
        [WARNING FileExisting-tc]: tc not found in system path
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

[[email protected] ~]#

Volvemos al nodo Master

[[email protected] ~]# kubectl get nodes
NAME                                       STATUS   ROLES    AGE     VERSION
ip-10-0-1-195.eu-west-1.compute.internal   Ready    master   8m16s   v1.19.4
ip-10-0-1-46.eu-west-1.compute.internal    Ready    <none>   51s     v1.19.4
ip-10-0-1-61.eu-west-1.compute.internal    Ready    <none>   37s     v1.19.4
[[email protected] ~]#

Desplegando un POD

A modo de ejemplo, vamos a desplegar un contenedor o POD, como se le llama en Kubernetes. Desplegaremos un nginx:

[[email protected] ~]# kubectl apply -f https://k8s.io/examples/controllers/nginx-deployment.yaml
deployment.apps/nginx-deployment created
[[email protected] ~]# kubectl get deployments
NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   0/3     3            0           21s
[[email protected] ~]#

Hay que esperar un ratito para verlos en estado running, pero podemos ver ya el proceso de creación del POD:

[[email protected] ~]# kubectl get pods --show-labels
NAME                                READY   STATUS              RESTARTS   AGE     LABELS
nginx-deployment-66b6c48dd5-whtsx   0/1     ContainerCreating   0          2m12s   app=nginx,pod-template-hash=66b6c48dd5
nginx-deployment-66b6c48dd5-xhgqq   0/1     ContainerCreating   0          2m12s   app=nginx,pod-template-hash=66b6c48dd5
nginx-deployment-66b6c48dd5-xhvfl   0/1     ContainerCreating   0          2m12s   app=nginx,pod-template-hash=66b6c48dd5
[[email protected] ~]#

También podemos consultar el número de réplicas del POD:

[[email protected] ~]# kubectl get rs
NAME                          DESIRED   CURRENT   READY   AGE
nginx-deployment-66b6c48dd5   3         3         0       9m2s
[[email protected] ~]#

El resto de comandos y tareas que podemos realizar con los contenedores o PODs ya las hemos visto anteriormente en este tutorial, por lo que no es necesario volver a explicar todos los comandos.

¿Te ha gustado? Compártelo

Share on facebook
Share on twitter
Share on linkedin
Share on whatsapp
Share on telegram
Share on email
About Author

Contenido Relacionado

Artículos Recientes

Deja un comentario