Ha pasado más de un año desde el primer post donde tratábamos de explicar las bases de montar una infraestructura Oracle como código a través de Docker. Desde entonces, los repositorios oficiales de Oracle  han ido creciendo y ya contamos con imágenes y ejemplos de muchísimos productos, plataformas y escenarios. En el caso de WebLogic, tenemos incluso algún ejemplo sobre el que montar WebLogic sobre Kubernetes(K8s).

Kubernetes es, desde hace tiempo, el orquestador de contenedores “de facto”, tanto es así que actualmente viene incluido en la propia versión de Docker CE. Esto nos permite poder realizar nuestras pruebas en local sobre K8s, de una manera más rápida ya que no tendremos que hacer la instalación desde cero, que es cuanto menos compleja o usar minikube

La idea de este post es tener un primer acercamiento a Kubernetes y su gestión para, finalmente, dar el salto a usar operadores e infraestructura de Oracle sobre Kubernetes. Sobretodo a nivel de concepto ya que, en mi opinión, el futuro pasa por ir hacia plataformas donde esté todo ya integrado y se nos abstraiga de cierta complejidad de base como puede ser Oracle Containers y Developer Cloud Service o la plataforma OpenShift entre otros.

Habilitar k8s en docker ce

Tan sencillo como ir a las preferencias de Docker y habilitarlo.

A partir de ahí podremos ya realizar cualquier tarea vía terminal con kubectl pero siempre se agradece acceder a la consola gráfica de administración de K8s que, posteriormente, usaremos para escalar nuestra aplicación.

Para ello, siguiendo la documentación oficial:

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

Para acceder a la consola desde fuera, primero realizaremos:

kubectl proxy  

De esta forma, podremos acceder mediante:
http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/

Para acceder al dashboard, desde la versión 1.7, se tiene que hacer de forma segura. Aquí está la documentación oficial sobre ello. Pero para hacer pequeñas pruebas en local podemos ir a la opción de Skip y no registrarnos al acceder.

Desplegar una aplicación sobre k8s

Una vez lo tengamos instalado, vamos a crear una aplicación demo, el holamundo de la documentación de ejemplo de kubernetes. Ahí está explicado para ejecutar en minikube, pero es prácticamente igual si obviamos esa parte.

No es más que un fichero js (server.js) con un holamundo.

var http = require('http');  
var handleRequest = function(request, response) {  
  console.log('Received request for URL: ' + request.url);
  response.writeHead(200);
  response.end('Hello World!');
};
var www = http.createServer(handleRequest);  
www.listen(8080);  

Posteriormente crearemos una imagen docker que será la que a continuación desplegaremos en k8s. Para ello crearemos el fichero Dockerfile en el mismo directorio donde tenemos el fichero server.js

FROM node:8  
EXPOSE 8080  
COPY server.js .  
CMD node server.js  

//creamos la imagen
docker build -t hello-node:v1 .  

//desplegamos sobre kubernetes
kubectl run hello-node --image=hello-node:v1 --port=8080  
//la hacemos accesible desde fuera
kubectl expose deployment hello-node --type=LoadBalancer  

Ahora desde http://localhost:8080/ deberíamos acceder a nuestro holamundo.

Escalado de nuestra aplicación

Por defecto, si no indicamos lo contrario, los despliegues se crean en el namespace default.

Para aumentar o reducir el número de instancias (pods) de nuestro despliegue podemos hacerlo vía línea de comandos o desde la propia UI del dashboard.

Monitorización

Como era de esperar, a medida que nuestra infraestructura y nuestras aplicaciones caminan hacia soluciones dockerizadas, un sistema de monitorización y alertas sobre toda nuestra arquitectura y aplicaciones obtiene un peso muy importante, sobre todo por la complejidad del sistema que hay por debajo.

En este enlace podemos ver cómo montar un sistema basado en Prometheus y Grafana, de forma que podamos ver los recursos y metricas de nuestro holamundo.

Para ello utilizaremos el operador kubernetes de Prometheus y el administrador de paquetes de k8s helm

Un operador nos va a facilitar mucho el trabajo ya que nos proporciona un empaquetado y una forma de administrar y gestionar el despliegue sobre k8s de una forma mas transparente y ágil.

A medida que vayamos realizando peticiones, podremos ver qué pod esta realmente sirviendo la petición.

WebLogic k8 sample

Desde el punto de vista de kubernetes, Oracle también ha realizado una labor importante  y contamos con ejemplos ya montados y probados que nos pueden servir de base para nuestros escenarios reales.
En este caso, un cluster de WebLogic 12c que irá aumentando o reduciendo en función de la política que definamos basada en WLDF.

Operador k8s de WebLogic

Y la guinda del pastel la tenemos con el operador oficial de Oracle para WebLogic. Con ello, además de poder gestionar toda nuestra infraestructura Weblogic como si de código se tratara, podremos escalar nuestra infraestructura en base a WLDF, Prometheus/Grafana u otros y viene integrado con ElasticSearch y Kibana.

Conclusiones

Como se comentaba al principio de este post, en las últimas fechas se ha producido una mejora sustancial en la disponibilidad de herramientas desde los propios fabricantes que facilitan la integración de plataformas históricamente propietarias en ambientes gestionados mediante prácticas DevOps. Especialmente interesante es el uso de kubernetes / docker, dado que se están convirtiendo es estándares de facto en este paradigma.