Tutorial de Kubernetes – Parte 4: Configurando tu API

Dificultad: Fácil
Tiempo de Lectura: 5 minutos

En el tutorial del día de hoy, vamos a hablar sobre una de las herramientas más importantes y potentes que contamos con Kubernetes que es la API.

Hoy día trabajar con APIs nos traen muchos beneficios, como ser, el hecho de poder realizar tareas desde cualquier lugar, así como también poder interactuar con sistemas en diferentes lenguajes, etc; Por lo cual sin lugar a dudas saber utilizarla en Kubernetes nos abrirá un abanico de posibilidades para nuestro sistema.

Los detalles de la API de Kubernetes se encuentran documentados utilizando Swagger y OpenAPI lo cual nos permitirá de forma intuitiva reconocer los recursos, las opciones que tenemos y también cómo utilizarlos, especialmente si ya has utilizado estas herramientas anteriormente, aunque aún si no lo has hecho, son muy fáciles de entender.

Por sobretodo, nos permitirá contar con los detalles de cada una de forma fácil y visual, para simplificar el proceso.

Importante: algo importante a mencionar es que los ejemplos que veremos a continuación no cuentan con seguridad. Es decir que simplemente veremos los primeros pasos para realizar request a la API de Kubernetes, pero no estaremos trabajando con autenticación.

Iniciando Swagger

Ahora bien, para poder ver qué recursos tenemos en nuestro sistema disponible para utilizar, vamos a tener que ver la documentación que Kubernetes nos proporciona y para ello lo más sencillo es iniciar Swagger en nuestro servidor master, el cual nos dirá exactamente qué tenemos disponible y cómo utilizarlo.

  • Primero que nada, accedemos a nuestro nodo master y como root agregamos en el archivo “/etc/kubernetes/manifests/kube-apiserver.yaml ” la siguiente línea:
nano -w /etc/kubernetes/manifests/kube-apiserver.yaml
--enable-swagger-ui
  • Debería quedarnos de la siguiente forma

  • Ahora procedemos a reiniciar el servicio
systemctl daemon-reload && systemctl restart kubelet
  • E iniciamos el proxy de Kubernetes. Esto lo realizamos como un usuario común, no root.
kubectl proxy --address 0.0.0.0 --accept-hosts='^*$'
  • Ahora bastará con ingresar a la siguiente URL y ya podremos ver los ressources disponibles. Simplemente debemos cambiar IP_MASTER por la ip de nuestro servidor master.
http://IP_MASTER:8001/swagger-ui 
  • Y allí deberíamos de ver algo como lo siguiente. Es normal si demora un poco en cargar, pues primero verificará los recursos disponibles para listarlos.

  Trabajando con la API de Kubernetes

Ahora que ya sabemos los recursos que tenemos disponibles, así como también la información que necesitamos para poder utilizarlo, es hora de realizar un par de pruebas.

La prueba más sencilla que podemos realizar es un simple GET a la API, para la cual no necesitaremos instalar ningún tipo de Software, sino que simplemente con el Navegador será suficiente.

Por ejemplo, podemos acceder a la siguiente URL para listar las versiones de la API que tenemos.

http://192.168.1.160:8001/api

Allí veremos algo como lo siguiente:

Creando pods desde la API

Ahora podemos realizar un request más avanzado. Por ejemplo intentemos crear un nuevo pod y eliminarlo vía API. Para ello podemos utilizar la herramienta Postman para enviar el request vía post. El recurso que utilizaremos será “http://192.168.1.160:8001/api/v1/namespaces/default/pods”.

Una vez que la tengas instalada bastará con realizar lo siguiente para poder realizar el request y crear el pod.

  1. El primer paso será abrir instalar y abrir Postman
  2. Luego procedemos a seleccionar el método Post
  3. Vamos a la opción Header
  4. Agregamos en key “Content-Type” y en value “application/json”
  5. Ingresamos la URL a la que debemos llamar para crear el pod
  6. Seleccionamos la opción Body
  7. E ingresamos en el cuerpo del request, el json con la configuración para crear nuestro nuevo pod
  8. Ahora procedemos a enviar el request

Ejemplo del paso 2 al 5

 

Ahora veamos un ejemplo de configuración, envío y recepción al momento de crear el pod.

En el body del request colocamos el siguiente ejemplo, que nos creará un nuevo pod con Nginx 1.7.9 llamado apipod.

{
    "apiVersion": "v1",
    "kind": "Pod",
    "metadata": {
        "name": "apipod"
    },
    "spec": {
        "containers": [
            {
                "name": "nginx",
                "image": "nginx:1.7.9",
                "ports": [
                    {
                        "containerPort": 80
                    }
                ]
            }
        ]
    }
}

Ejemplo del paso 6 al 8

Una vez enviado el request podemos en nuestro master chequear si el nuevo pod está en proceso de creación.

kubernetesmaster:~$ kubectl get pods
NAME                                READY     STATUS    RESTARTS   AGE
apipod                              0/1       Pending   0          56s
nginx-5gf4b                         1/1       Running   1          68d

Como podemos ver, nuestro pod se encuentra en estado pending, y al cabo de unos minutos debería de estar listo para ser utilizado.

Obtener información de un Pod

Algo que también nos puede ser de ayuda, es obtener la información de un pod en específico, por ejemplo en este caso podría ser del que hemos creado recientemente, es decir “apipod”.

Para ello simplemente bastará con llamar a la URL: http://192.168.1.160:8001/api/v1/namespaces/default/pods/{pod_name}

Lo cual podemos hacerlo desde el navegador mismo o desde Postman con el método GET, siempre cambiando “{pod_name}” por el nombre de nuestro pod, en este caso “apipod”.

Un ejemplo de lo que obtendríamos sería:

 

Proceso de eliminación de un pod.

Los pasos para eliminar un pod son relativamente similares, bastará con realizar algunas modificaciones pequeñas en nuestra configuración de Postman.

  1. Cambiamos el método POST por DELETE
  2. Cambiamos la URL a “http://192.168.1.160:8001/api/v1/namespaces/default/pods/{pod_name}”
  3. Quitamos lo que tenemos en Body
  4. Enviamos el request

Un ejemplo de como enviar el request sería:

 

Ahora si verificamos nuevamente con “kubectl get pods” podemos ver que el pod que habíamos creado anteriormente ya no existe

sabrina@kubernetesmaster:~$ kubectl get pods
NAME                                READY     STATUS    RESTARTS   AGE
nginx-5gf4b                         1/1       Running   1          68d

 

Utilizando la API en PHP

Ya que hemos mencionado anteriormente que uno de los más grandes beneficios de que Kubernetes tenga una API disponible es el hecho de poder manejarlo a través de nuestras propias aplicaciones utilizando los lenguajes que deseamos, veamos un ejemplo muy sencillo de cómo sería utilizando PHP.

Creando un pod

<?php
// API URL
$api="http://192.168.1.160:8001/api/v1/namespaces/default/pods/";

// Preparando la data
$payload = '{
    "apiVersion": "v1",
    "kind": "Pod",
    "metadata": {
        "name": "apipod"
    },
    "spec": {
        "containers": [
            {
                "name": "nginx",
                "image": "nginx:1.7.9",
                "ports": [
                    {
                        "containerPort": 80
                    }
                ]
            }
        ]
    }
}';

// Preparar el resource
$ch = curl_init($api);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLINFO_HEADER_OUT, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
 
// Seteando los Headers
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Content-Type: application/json',
    'Content-Length: ' . strlen($payload))
);
 
// Enviar el request
$result = curl_exec($ch);
 
// Cerrar la conexión
curl_close($ch);

// Mostramos la respuesta
print_r($result);

Obteniendo la información de un pod

<?php
// API URL
$api="http://192.168.1.160:8001/api/v1/namespaces/default/pods/apipod";

//Preparando request
$ch = curl_init($api);
curl_setopt($ch, CURLOPT_HEADER, 0);
$response = curl_exec($ch);
curl_close($ch);

//Mostrar Resultado
print_r($response);

Eliminando un pod

<?php
// Api URL
$api="http://192.168.1.160:8001/api/v1/namespaces/default/pods/apipod";

// Preparando request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $api);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
$result = curl_exec($ch);
curl_close($ch);

//Mostrar resultado
print_r($result);

Conclusión

Como vemos trabajar con la API de Kubernetes es algo sumamente sencillo y que por sobretodo nos trae muchas ventajas y flexibilidad a la hora de trabajar con él.

Tengamos en cuenta que el hecho de que Kubernetes cuente con una API, implica que nosotros podremos desarrollar aplicaciones, scripts, etc; e interactuar con la API desde casi cualquier lenguaje y lugar, para poder manipular el ambiente de producción o desarrollo de forma casi ilimitada.

Es decir que es posible con un par de clicks desde una pc un móvil sin importar donde estés, agregar, quitar y editar pods, según lo necesites, por dar un ejemplo. Ya que en realidad la API de Kubernetes nos ofrece mucho más que eso, y bastará con saber lo que necesitas realizar, que seguramente la opción estará disponible en ella.


¿Te resultó útil el artículo? Compártelo con tus colegas: