Primeros pasos con Kubernetes

Instalar en la nube de Google

Kubernetes fue desarrollado originalmente por Google para potenciar su Container Engine. Como tal, los clústeres de Kubernetes son ciudadanos de primera clase en Google.

La creación de un clúster de Kubernetes en el motor del contenedor requiere el comando “gcloud” del SDK de Google Cloud. Para instalar este comando localmente, use una de las siguientes opciones:

  • use el instalador interactivo (la forma más fácil para los recién llegados):
curl https://sdk.cloud.google.com | bash
exec -l $SHELL
gcloud init
  • descargue el SDK de https://cloud.google.com/sdk/ y ejecute el archivo de instalación apropiado.

    For example, to install in Linux (x86_64):

curl -Lo gcloud-sdk.tar.gz https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-sdk-142.0.0-linux-x86_64.tar.gz
tar xvf ./gcloud-sdk.tar.gz
./google-cloud-sdk/install.sh
gcloud init

Una vez que gcloud esté instalado, cree un clúster de Kubernetes con:

# Give our cluster a name
CLUSTER_NAME=example-cluster

# Number of machines in the cluster.
NUM_NODES=3
    
gcloud container clusters create $CLUSTER_NAME --num_nodes=$NUM_VMS

Kubectl en la línea de comandos

Una vez que tenga un clúster en ejecución, puede administrarlo con el comando kubectl. Puede obtener la mayoría de los comandos con el comando kubectl --help, pero le muestro los comandos más comunes para administrar y obtener información sobre su clúster, nodos, pods, servicios y etiquetas.


Para obtener información sobre el clúster, puede usar el siguiente comando

kubectl cluster-info

Le mostrará la dirección y el puerto de ejecución.


Para obtener información breve sobre los nodos, pods, servicios, etc. o cualquier recurso que tenga un lugar en el clúster, puede usar el siguiente comando

kubectl get {nodes, pods, services, ...}

La salida es principalmente una línea por recurso.


Para obtener una descripción detallada de los recursos, puede usar el indicador describe para kubectl

kubectl describe {nodes, pods, ...}

Las aplicaciones implementadas solo son visibles dentro del clúster, por lo que si desea obtener el resultado desde fuera del clúster, debe crear una ruta entre la terminal y el clúster de Kubernetes.

kubectl proxy

Abrirá una API, donde podemos obtener todo del clúster. Si desea obtener el nombre de los pods para obtener información, debe usar el siguiente comando:

kubectl get pods -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}'

Enumerará los pods para su uso posterior.

curl http://localhost:8001/api/v1/proxy/namespaces/default/pods/{pod_name}/

Otros dos comandos comunes son obtener registros y ejecutar un comando desde/en la aplicación en contenedor.

kubectl logs {pod_name}
kubectl exec {pod_name} {command}

La configuración de la finalización de pestañas para su shell se puede hacer con:

source <(kubectl completion zsh)   # if you're using zsh
source <(kubectl completion bash)  # if you're using bash

o más programáticamente:

source <(kubectl completion "${0/-/}")

Instalación de Minikube

Minikube crea un clúster local de máquinas virtuales para ejecutar Kubernetes. Es el método más simple para ensuciarse las manos con Kubernetes en su máquina local.

La documentación para Minikube se puede encontrar en http://kubernetes.io/docs/getting-started-guides/minikube/

Requisitos

Para verificar si el soporte de virtualización está habilitado, ejecute el comando apropiado desde abajo. El comando generará algo si la virtualización está habilitada.

# On Linux
cat /proc/cpuinfo | grep 'vmx\|svm'
# On OSX
sysctl -a | grep machdep.cpu.features | grep VMX

Instalación

Minikube es un solo binario. Por lo tanto, la instalación es tan fácil como descargar el binario y colocarlo en su camino.

# Specify the version of minikube to download.
# Latest version can be retrieved from 
# https://github.com/kubernetes/minikube/releases
VERSION=v0.16.0

# If on Linux
OS=linux  
# If on OSX
# OS=darwin

# URL to download minikube binary from
URL=https://storage.googleapis.com/minikube/releases/$VERSION/minikube-$OS-amd64

# Download binary and place in path.
curl -Lo minikube $URL 
chmod +x minikube 
sudo mv minikube /usr/local/bin/

Uso

Para iniciar un nuevo clúster:

minikube start

Esto creará un nuevo clúster de máquinas virtuales locales con Kubernetes ya instalado y configurado.

Puede acceder al panel de control de Kubernetes con:

minikube dashboard

Minikube crea un contexto relacionado para kubectl que se puede usar con:

kubectl config use-context minikube

Una vez que esté listo, se pueden usar los Kubernetes locales:

kubectl run hello-minikube --image=gcr.io/google_containers/echoserver:1.4 --port=8080
kubectl expose deployment hello-minikube --type=NodePort
curl $(minikube service hello-minikube --url)

Para detener el clúster local:

minikube stop

Para eliminar el clúster local, tenga en cuenta que se asignará una nueva IP después de la creación:

minikube delete

Configurar kubectl

Un clúster de Kubernetes se controla mediante el comando kubectl. El método de configuración de kubectl depende de dónde esté instalado Kubernetes.

Google Cloud (motor de contenedores)

Para instalar kubectl con el SDK de Google Cloud:

gcloud components install kubectl

Para configurar kubectl para controlar un clúster de Kubernetes existente en Container Engine:

gcloud container clusters get-credentials $CLUSTER_NAME

#Minikube

Al usar minikube, el binario kubectl debe descargarse manualmente y colocarse en la ruta.

# Version of Kubernetes.
K8S_VERSION=$(curl -sS https://storage.googleapis.com/kubernetes-release/release/stable.txt)
# Operating System. Can be one of {linux, darwin}
GOOS=linux
# Architecture. Can be one of {386, amd64, arm64, ppc641e}
GOARCH=amd64

# Download and place in path.
curl -Lo kubectl http://storage.googleapis.com/kubernetes-release/release/${K8S_VERSION}/bin/${GOOS}/${GOARCH}/kubectl
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

El binario minikube configura automáticamente kubectl al iniciar un clúster.

minikube start
# kubectl is now ready to use!

Hola Mundo

Una vez que su clúster de Kubernetes se esté ejecutando y kubectl esté configurado, podrá ejecutar su primera aplicación con unos pocos pasos. Esto se puede hacer usando los comandos imperativos que no necesitan archivos de configuración.

Para ejecutar una aplicación, debe proporcionar un nombre de implementación (bootcamp), la ubicación de la imagen del contenedor (docker.io/jocatalin/kubernetes-bootcamp:v1) y el puerto (8080)

$ kubectl run bootcamp --image=docker.io/jocatalin/kubernetes-bootcamp:v1 --port=8080

Confirme que funcionó con:

$ kubectl get deployments
NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
bootcamp               1         1         1            1         6s

Para exponer su aplicación y hacerla accesible desde el exterior, ejecute:

$ kubectl expose deployment/bootcamp --type="LoadBalancer" --port 8080

Confirme que funcionó con:

$ kubectl get services
NAME                  CLUSTER-IP   EXTERNAL-IP         PORT(S)    AGE
kubernetes            10.0.0.1     <none>              443/TCP    3m
bootcamp              10.3.245.61  104.155.111.170     8080:32452/TCP   2m

Para acceder a los servicios, utilice la IP externa y el puerto de la aplicación, p. como esto:

$ export EXTERNAL_IP=$(kubectl get service bootcamp --output=jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ export PORT=$(kubectl get services --output=jsonpath='{.items[0].spec.ports[0].port}')
$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-390780338-2fhnk | v=1

Lo mismo se podría hacer manualmente con los datos proporcionados en:

$ kubectl describe service bootcamp
Name:                   bootcamp
Namespace:              default
Labels:                 run=bootcamp
Selector:               run=bootcamp
Type:                   LoadBalancer
IP:                     10.3.245.61
LoadBalancer Ingress:   104.155.111.170
Port:                   <unset> 8080/TCP
NodePort:               <unset> 32452/TCP
Endpoints:              10.0.0.3:8080
... events and details left out ....

$ export NODE=104.155.111.170
$ export PORT=8080

Una vez que esto funcionó, puede escalar su aplicación con:

$ kubectl scale deployments/bootcamp --replicas=4

Y comprueba el resultado con:

$ kubectl get deployments
NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
bootcamp               4         4         4            4         30s

$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-390780338-2fhnk | v=1
$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-390780338-gmtv5 | v=1

Tenga en cuenta el cambio de identificación de la cápsula.

Para impulsar una nueva versión de la aplicación, ejecute:

kubectl set image deployments/bootcamp bootcamp=jocatalin/kubernetes-bootcamp:v2

Y confirmarlo con:

$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-284539476-gafwev3 | v=2

La limpieza finalmente se hace con:

$ kubectl delete deployment bootcamp
$ kubectl delete service bootcamp