Kubernetes en AWS con Kops

0
3207

Índice de contenidos


1. Entorno

Este tutorial está escrito usando el siguiente entorno:

  • Hardware: Slimbook Pro 2 13.3″ (Intel Core i7, 32GB RAM)
  • Sistema Operativo: LUbuntu 18.04


2. Introducción

Nota importante: seguir los pasos de este tutorial supone costes en la cuenta de AWS.

En este tutorial vamos a ver los pasos necesarios para montar un clúster de Kubernetes en producción en el cloud de Amazon gracias a Kops («Kubernetes Operations»).

Para ello vamos a seguir esta guía de Kumori Labs pero comentando los cambios que hay que hacer para adaptarla a las últimas versiones.

Para continuar con esta guía necesitamos como pre-requisitos:

  • Clientes de Vagrant, VirtualBox, Git y AWS cli instalados en nuestra máquina.
  • Una cuenta de administrador en AWS.
  • Un nombre de dominio real comprado en algún proveedor como el propio AWS, Google Domains, GoDaddy, etc…


3. Vamos al lío

Lo primero que vamos a hacer es crear una cuenta de usuario especifica para el manejo de Kubernetes con Kops.

Para ello haciendo uso del CLI de AWS creamos un grupo en AWS llamado «kops».

$> aws iam create-group --group-name kops

Ahora establecemos una variable de entorno con todos los permisos que otorgamos a los miembros de este grupo.

export arns="
arn:aws:iam::aws:policy/AmazonEC2FullAccess
arn:aws:iam::aws:policy/AmazonRoute53FullAccess
arn:aws:iam::aws:policy/AmazonS3FullAccess
arn:aws:iam::aws:policy/IAMFullAccess
arn:aws:iam::aws:policy/AmazonVPCFullAccess"

Ejecutamos una sentencia donde recorremos cada uno de los anteriores permisos y se lo asignamos al grupo kops.

$> for arn in $arns; do aws iam attach-group-policy --policy-arn "$arn" --group-name kops; done

Creamos el usuario «kops».

$> aws iam create-user --user-name kops

Ahora añadimos este usuario al grupo kops.

$> aws iam add-user-to-group --user-name kops --group-name kops

Y por último creamos el access key para el usuario «kops».

$> aws iam create-access-key --user-name kops

Este comando nos va a devolver un JSON con los campos SecretAccessKey y AccessKeyID que vamos a almacenar en las siguientes variables de entorno para interactuar con AWS.

$> export AWS_ACCESS_KEY_ID="AWS Access Key ID"
$> export AWS_SECRET_ACCESS_KEY="AWS Secret Access Key"

También es necesario tener creadas las credenciales de SSH en nuestra máquina. Las cuales se almacenan en ~/.ssh/id_rsa.pub y ~/.ssh/id_rsa. Si trabajas habitualmente con Git casi seguro que ya las tienes creadas y si no es tan sencillo como ejecutar el siguiente comando dejando la ruta por defecto.

$> ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Es el momento de clonar el siguiente proyecto.

$> git clone https://github.com/kumorilabs/getting-to-know-k8s.git
$> cd getting-to-know-k8s.git

Un paso importante antes de arrancar Vagrant es abrir el fichero /scripts/provision-vagrant.sh para verificar las versiones y su compatibilidad. A mi me ha ido bien con las siguientes versiones:

export KUBECTL_VERSION="1.11.1"
export KUBEFED_VERSION="1.11.1"
export KOPS_VERSION="1.10.0"
export HUGO_VERSION="0.47"
export TERRAFORM_VERSION="0.11.8"

En este punto ya estamos en disposición de arrancar el proyecto con Vagrant para que nos cree una instancia con todas las herramientas (awscli, kops, kubectl, …) instaladas y configuradas, así que ejecutamos:

$> vagrant up

Pasados unos minutos (tardará más porque se tendrá que descargar el box) ya podemos entrar en la máquina con el comando:

$> vagrant ssh

A partir de este punto todos los comandos los vamos a ejecutar desde la máquina de Vagrant que en el arranque ha cogido las credenciales del usuario «kops» y las claves de SSH.

El alcance de este tutorial es la creación del clúster de Kubernetes haciendo uso de Kops así que lo primero que vamos a hacer es preparar unas variables de entorno que nos ayudarán en el proceso.

Primero establecemos el valor para DOMAIN_NAME el cual tiene que ser el nombre de dominio o sudominio que tengamos comprado.

$> export DOMAIN_NAME="tunombredominio.org"

Después vamos a establecer un nombre de clúster que vamos a utilizar para identificarlo junto con el DOMAIN_NAME.

$> export CLUSTER_ALIAS="k8s"

Ahora componemos el nombre completo del clúster.

$> export CLUSTER_FULL_NAME="${CLUSTER_ALIAS}.${DOMAIN_NAME}"

Y establecemos la zona de disponibilidad donde queremos crear el clúster.

$> export CLUSTER_AWS_AZ="eu-west-1b"

Otro paso previo necesario para la creación del clúster es crear un bucket de S3 que Kops va a utilizar para almacenar los ficheros de configuración necesarios. Para crearlo ejecutamos:

$> aws s3api create-bucket --bucket ${CLUSTER_FULL_NAME}-state

Y establecemos la variable de entorno.

$> export KOPS_STATE_STORE="s3://${CLUSTER_FULL_NAME}-state"

Antes de crear el clúster vamos a verificar que nuestro nombre de dominio tiene disponible correctamente los servidores de DNS, ya que de lo contrario no podremos crear el clúster.

Para ello utilizamos la herramienta dig disponible en el box de Vagrant y ejecutamos:

$> dig NS tunombredominio.org

Hasta que este comando no responda con algo similar a esto, no podrás crear el clúster.

tunombredominio.org.		21600	IN	NS	ns-cloud-e1.googledomains.com.
tunombredominio.org.		21600	IN	NS	ns-cloud-e2.googledomains.com.
tunombredominio.org.		21600	IN	NS	ns-cloud-e3.googledomains.com.
tunombredominio.org.		21600	IN	NS	ns-cloud-e4.googledomains.com.

Si esto no es así tendrás que hacer las modificaciones necesarias en tu servidor de dominio y esperar a que las modificaciones de DNS se propaguen para volver a intentarlo.

En caso de que sea correcto, ya podemos crear el clúster con el siguiente comando:

$> kops create cluster \
    --name=${CLUSTER_FULL_NAME} \
    --zones=${CLUSTER_AWS_AZ} \
    --master-size="t2.medium" \
    --node-size="t2.medium" \
    --node-count="2" \
    --dns-zone=${DOMAIN_NAME} \
    --ssh-public-key="~/.ssh/id_rsa.pub" \
    --kubernetes-version="1.11.1"

Este comando no crea físicamente los elementos en AWS sino que nos permite un preview de lo que va a hacer. Para confirmar que queremos crear los elementos (y empezar con el coste) tenemos que ejecutar:

$> kops update cluster ${CLUSTER_FULL_NAME} --yes

Pasados unos minutos podremos ver en la web de AWS que se crean tres nuevas instancias, un master y dos nodos, con todos los grupos de permisos y el autoescalado configurado y que en la parte de Route 53 se han creado nuevas entradas de RecordSets dentro del Hosted Zone. Hasta que estas entradas no cambien la IP por defecto 203.0.113.123 por unas reales asociadas al nombre de dominio, el clúster no estará operativo.

Para comprobar que el clúster funciona, podemos ejecutar algún comando de Kubernetes como:

$> kubectl get nodes

Y ver que nos responde con el nodo master y los dos nodos asociados.

Otro paso que podemos hacer es instalar el dashboard ejecutando:

$> kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml

Por defecto la seguridad del dashboard está habilitada así que tenemos que ejecutar el siguiente comando para ver el username y la password:

$> kubectl config view --minify

Ahora accedemos al dashboard a través del navegador a la URL: https://api.k8s.tunombredominio.org/api/v1/namespaces/kube-system/services/kubernetes-dashboard:/proxy/

Ingresamos el username y la password y ya estamos dentro, pero nos damos cuenta de que pinchando en las opciones de menú vemos que por seguridad todas las operaciones están deshabilitadas, con un mensaje del tipo: deployments.apps is forbidden: User «system:serviceaccount:kube-system:kubernetes-dashboard» cannot list deployments.apps in the namespace «default»

Para habilitar los permisos tenemos que crear un fichero dashboard-admin.yaml con el siguiente contenido:

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: kubernetes-dashboard
  labels:
    k8s-app: kubernetes-dashboard
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: kubernetes-dashboard
  namespace: kube-system

Y lo ejecutamos sobre el clúster con el comando:

$> kubectl create -f dashboard-admin.yaml

De esta forma ya podemos hacer las operaciones desde el dashboard aunque personalmente aconsejo realizarlas desde la línea de comandos.

Para eliminar el clúster, simplemente tenemos que ejecutar:

$> kops delete cluster ${CLUSTER_FULL_NAME} --yes 

Y si no lo estamos usando para otra cosa, también podemos borrar el bucket asociado.

$> aws s3api delete-bucket --bucket ${CLUSTER_FULL_NAME}-state


4. Conclusiones

Kubernetes se está convirtiendo en el estándar de facto para orquestar el despliegue de aplicaciones basadas en contenedores; que mejor que tenerlo disponible en el cloud gracias a AWS y Kops.

Cualquier duda o sugerencia en la zona de comentarios.

Saludos.

DEJA UNA RESPUESTA

Por favor ingrese su comentario!

He leído y acepto la política de privacidad

Por favor ingrese su nombre aquí

Información básica acerca de la protección de datos

  • Responsable:
  • Finalidad:
  • Legitimación:
  • Destinatarios:
  • Derechos:
  • Más información: Puedes ampliar información acerca de la protección de datos en el siguiente enlace:política de privacidad