{"id":97254,"date":"2020-10-17T02:42:32","date_gmt":"2020-10-17T00:42:32","guid":{"rendered":"https:\/\/prohoster.info\/blog\/administrirovanie\/prosti-openshift-my-nedostatochno-czenili-tebya-i-prinimali-kak-dolzhnoe"},"modified":"2020-10-17T02:42:32","modified_gmt":"2020-10-17T00:42:32","slug":"prosti-openshift-my-nedostatochno-czenili-tebya-i-prinimali-kak-dolzhnoe","status":"publish","type":"post","link":"https:\/\/prohoster.info\/es\/blog\/administrirovanie\/prosti-openshift-my-nedostatochno-czenili-tebya-i-prinimali-kak-dolzhnoe","title":{"rendered":"Lo siento, OpenShift, no te valoramos lo suficiente y te dimos por hecho","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Esta publicaci\u00f3n se escribe porque nuestros empleados han tenido muchas conversaciones con clientes sobre el desarrollo de aplicaciones en Kubernetes y las particularidades de dicho desarrollo en OpenShift.<\/p>\n

\"Lo
\n
\nNormalmente comenzamos con la tesis de que Kubernetes es simplemente Kubernetes, mientras que OpenShift es ya una plataforma Kubernetes, como Microsoft AKS o Amazon EKS. Cada una de estas plataformas tiene sus ventajas, orientadas a un p\u00fablico objetivo espec\u00edfico. Despu\u00e9s de esto, la conversaci\u00f3n fluye hacia la comparaci\u00f3n de las fortalezas y debilidades de plataformas concretas.
\n<\/a><\/noindex>
\nEn general, pensamos en escribir esta publicaci\u00f3n con una conclusi\u00f3n como: 'Escuchen, realmente da igual d\u00f3nde ejecutar el c\u00f3digo, en OpenShift, AKS, EKS, en alg\u00fan Kubernetes personalizado, s\u00ed, en cualquier Kubernetes' (para abreviar, llam\u00e9moslo KUK)<\/i> \u2013 es realmente f\u00e1cil, en ambos casos.<\/p>\n

Luego planeamos tomar un sencillo 'Hola Mundo' y, a trav\u00e9s de su ejemplo, mostrar qu\u00e9 tienen en com\u00fan y en qu\u00e9 se diferencian KUK y Red Hat OpenShift Container Platform (en adelante, OCP o simplemente OpenShift).<\/p>\n

Sin embargo, a medida que escrib\u00edamos esta publicaci\u00f3n, nos dimos cuenta de que nos hemos acostumbrado tanto a usar OpenShift que simplemente no nos damos cuenta de c\u00f3mo ha crecido y se ha convertido en una plataforma impresionante, que es mucho m\u00e1s que un simple distribuidor de Kubernetes. Hemos llegado a considerar la madurez y simplicidad de OpenShift como un hecho, pasando por alto su grandeza.<\/p>\n

En general, ha llegado el momento de un arrepentimiento activo, y ahora compararemos paso a paso la implementaci\u00f3n de nuestro 'Hola Mundo' en KUK y en OpenShift, y lo haremos de la manera m\u00e1s objetiva posible (bueno, tal vez alguna vez manifestando nuestra opini\u00f3n personal sobre el tema). Si te interesa una opini\u00f3n puramente subjetiva al respecto, puedes leerla aqu\u00ed (EN)<\/a><\/noindex>. En esta publicaci\u00f3n nos ce\u00f1iremos a los hechos y solo a los hechos.<\/p>\n

Cl\u00fasteres<\/h3>\n

\nAs\u00ed que, para nuestro 'Hola Mundo' necesitamos cl\u00fasteres. Desde un principio diremos que 'no' a nubes p\u00fablicas, para no tener que pagar por servidores, registros, redes, transferencia de datos, etc. Por lo tanto, optamos por un sencillo cl\u00faster de un solo nodo en Minikube<\/a><\/noindex> (para KUK) y Code Ready Containers<\/a><\/noindex> (para el cl\u00faster OpenShift). Ambas opciones son realmente f\u00e1ciles de instalar, pero requerir\u00e1n bastantes recursos en tu port\u00e1til.<\/p>\n

\"Lo<\/p>\n

Construcci\u00f3n en KUK<\/h3>\n

\nAs\u00ed que, \u00a1empecemos!<\/p>\n

Paso 1 \u2013 construimos nuestra imagen de contenedor<\/h4>\n

\nComenzar\u00e9 desplegando nuestro 'Hola Mundo' en minikube. Para esto necesitaremos:<\/p>\n

    \n
  1. 1. Docker instalado.<\/li>\n
  2. 2. Git instalado.<\/li>\n
  3. 3. Maven instalado (en este proyecto se utiliza el binario mvnw, por lo que no es necesario).<\/li>\n
  4. 4. En realidad, el c\u00f3digo fuente, es decir, un clon del repositorio github.com\/gcolman\/quarkus-hello-world.git<\/a><\/noindex><\/li>\n<\/ol>\n

    \nPrimero, hay que crear un proyecto Quarkus. No se asusten si nunca han trabajado con el sitio Quarkus.io: es f\u00e1cil. Simplemente eligen los componentes que desean usar en el proyecto (RestEasy, Hibernate, Amazon SQS, Camel, etc.), y luego Quarkus se encarga de configurar autom\u00e1ticamente el arquetipo de Maven y subir todo a GitHub. Es decir, literalmente, un solo clic del mouse y est\u00e1 listo. Por eso amamos Quarkus.<\/p>\n

    \"Lo<\/p>\n

    La forma m\u00e1s simple de construir nuestro 'Hello World' en una imagen de contenedor es usar la extensi\u00f3n quarkus-maven para Docker, que hace todo el trabajo necesario. Con la llegada de Quarkus, esto se ha vuelto muy f\u00e1cil y sencillo: solo a\u00f1aden la extensi\u00f3n container-image-docker y pueden crear im\u00e1genes con comandos de Maven.<\/p>\n

    .\/mvnw quarkus:add-extension -Dextensions=\"container-image-docker\"\n<\/code><\/pre>\n
    \nY, finalmente, construimos nuestra imagen usando Maven. Como resultado, nuestro c\u00f3digo fuente se convierte en una imagen de contenedor lista para ser ejecutada en un entorno de contenedores.<\/p>\n
    \"Lo<\/p>\n
    .\/mvnw -X clean package -Dquarkus.container-image.build=true\n<\/code><\/pre>\n
    \nEso es todo, ahora se puede ejecutar el contenedor con el comando docker run, mapeando nuestro servicio al puerto 8080 para poder acceder a \u00e9l.<\/p>\n
    docker run -i --rm -p 8080:8080 gcolman\/quarkus-hello-world\n<\/code><\/pre>\n
    \"Lo<\/p>\n
    Despu\u00e9s de que la instancia del contenedor se haya iniciado, solo queda verificar con el comando curl que nuestro servicio est\u00e9 funcionando:<\/p>\n
    \"Lo<\/p>\n
    As\u00ed que, todo funciona, y realmente fue f\u00e1cil y sencillo.<\/p>\n
    Paso 2 \u2013 enviamos nuestro contenedor al repositorio de im\u00e1genes de contenedores<\/h4>\n
    \nHasta ahora, la imagen que hemos creado se almacena localmente, en nuestro almacenamiento local de contenedores. Si queremos usar esta imagen en nuestro entorno de Kubernetes, debemos subirla a otro repositorio. Kubernetes no tiene estas funciones, por eso utilizaremos Docker Hub. Porque, en primer lugar, es gratuito, y en segundo lugar, (casi) todos lo hacen.<\/p>\n
    Esto tambi\u00e9n es muy simple, y solo se necesita tener una cuenta en Docker Hub.<\/p>\n
    As\u00ed que, subimos a Docker Hub y enviamos nuestra imagen all\u00ed.<\/p>\n
    \"Lo<\/p>\n
    Paso 3 \u2013 iniciamos Kubernetes<\/h4>\n
    \nHay muchas formas de construir la configuraci\u00f3n de Kubernetes para ejecutar nuestro 'Hello World', pero usaremos la m\u00e1s simple, ya que as\u00ed somos.<\/p>\n
    Primero, iniciamos el cl\u00faster minikube:<\/p>\n
    minikube start\n<\/code><\/pre>\n
    <\/p>\n
    Paso 4 \u2013 desplegamos nuestra imagen de contenedor<\/h4>\n
    \nAhora necesitamos convertir nuestro c\u00f3digo y la imagen del contenedor en configuraciones de Kubernetes. En otras palabras, necesitamos una definici\u00f3n de pod y deployment que apunte a nuestra imagen en Docker Hub. Una de las formas m\u00e1s sencillas de hacerlo es ejecutar el comando create deployment, especificando nuestra imagen:<\/p>\n
    \"Lo<\/p>\n
    kubectl create deployment hello-quarkus --image=gcolman\/quarkus-hello-world:1.0.0-SNAPSHOT\n<\/code><\/pre>\n
    \nCon este comando le hemos dicho a Kubernetes que cree una configuraci\u00f3n de deployment, que debe contener la especificaci\u00f3n del pod para nuestra imagen de contenedor. Este comando tambi\u00e9n aplicar\u00e1 esta configuraci\u00f3n a nuestro cl\u00faster minikube y crear\u00e1 un deployment que descargar\u00e1 nuestra imagen de contenedor y ejecutar\u00e1 el pod en el cl\u00faster.<\/p>\n
    Paso 5 \u2013 abrimos el acceso a nuestro servicio<\/h4>\n
    \nAhora que tenemos nuestro contenedor desplegado, es hora de pensar c\u00f3mo configurar el acceso externo a este servicio RESTful, que en realidad est\u00e1 programado en nuestro c\u00f3digo.<\/p>\n
    Hay muchas maneras de hacerlo. Por ejemplo, podemos usar el comando expose para crear autom\u00e1ticamente los componentes de Kubernetes correspondientes, como services y endpoints. De hecho, as\u00ed lo haremos, ejecutando el comando expose para nuestro objeto de deployment:<\/p>\n
    kubectl expose deployment hello-quarkus --type=NodePort --port=8080\n<\/code><\/pre>\n
    \nDeteng\u00e1monos un momento en la opci\u00f3n ' --type' del comando expose.<\/p>\n
    Cuando hacemos un expose y creamos los componentes necesarios para ejecutar nuestro servicio, entre otras cosas, necesitamos que se pueda conectar externamente al servicio hello-quarkus, que est\u00e1 dentro de nuestra red definida por software. Y el par\u00e1metro tipo<\/b> nos permite crear y conectar elementos como balanceadores de carga para enrutar el tr\u00e1fico a esta red.<\/p>\n
    Por ejemplo, al especificar type=LoadBalancer<\/b>, autom\u00e1ticamente inicializamos un balanceador de carga en la nube p\u00fablica para conectarnos a nuestro cl\u00faster de Kubernetes. Esto, por supuesto, es fant\u00e1stico, pero hay que entender que tal configuraci\u00f3n estar\u00e1 estrechamente vinculada a una nube p\u00fablica espec\u00edfica y ser\u00e1 m\u00e1s dif\u00edcil de trasladar entre instancias de Kubernetes en diferentes entornos.<\/p>\n
    En nuestro ejemplo type=NodePort<\/b>, es decir, la conexi\u00f3n a nuestro servicio se realiza a trav\u00e9s de la direcci\u00f3n IP del nodo y el n\u00famero del puerto. Esta opci\u00f3n permite no utilizar ninguna nube p\u00fablica, pero requiere una serie de pasos adicionales. Primero, necesitamos nuestro propio equilibrador de carga, por lo que desplegaremos un equilibrador de carga NGINX en nuestro cl\u00faster.<\/p>\n
    Paso 6 \u2013 Instalamos el equilibrador de carga<\/h4>\n
    \nMinikube tiene una serie de funciones de plataforma que facilitan la creaci\u00f3n de los componentes necesarios para el acceso externo, como los controladores de ingreso. Minikube viene con un controlador de ingreso Nginx, y solo necesitamos activarlo y configurarlo.<\/p>\n
    minikube addons enable ingress\n<\/code><\/pre>\n
    \nAhora, con un solo comando, crear\u00e9 el controlador de ingreso Nginx, que funcionar\u00e1 dentro de nuestro cl\u00faster minikube:<\/p>\n
    ingress-nginx-controller-69ccf5d9d8-j5gs9 1\/1 En ejecuci\u00f3n 1 33m\n<\/code><\/pre>\n
    <\/p>\n
    Paso 7 \u2013 Configuramos el ingreso<\/h4>\n
    \nAhora necesitamos configurar el controlador de ingreso Nginx para que reconozca las solicitudes hello-quarkus.<\/p>\n
    \"Lo<\/p>\n
    \"Lo<\/p>\n
    Y, por \u00faltimo, necesitamos aplicar esta configuraci\u00f3n.<\/p>\n
    \"Lo<\/p>\n
    kubectl apply -f ingress.yml\n<\/code><\/pre>\n
    \"Lo<\/p>\n
    Dado que estamos haciendo todo esto en nuestra computadora, simplemente a\u00f1adimos la direcci\u00f3n IP de nuestro nodo al archivo \/etc\/hosts para dirigir las solicitudes http a nuestro minikube en el equilibrador de carga NGINX.<\/p>\n
    192.168.99.100 hello-quarkus.info\n<\/code><\/pre>\n
    \nListo, ahora nuestro servicio minikube est\u00e1 disponible externamente a trav\u00e9s del controlador de ingreso Nginx.<\/p>\n
    \"Lo<\/p>\n
    Bueno, eso fue f\u00e1cil, \u00bfverdad? \u00bfO no tanto?<\/h3>\n
    \"Lo<\/p>\n
    Ejecutando en OpenShift (Code Ready Containers)<\/h3>\n
    \nAhora veamos c\u00f3mo se hace todo esto en la Red Hat OpenShift Container Platform (OCP).<\/p>\n
    Al igual que con minikube, elegimos la opci\u00f3n de cl\u00faster de un solo nodo en OpenShift en forma de Code Ready Containers (CRC). Anteriormente se conoc\u00eda como minishift y se basaba en el proyecto OpenShift Origin, y ahora es CRC y est\u00e1 construido sobre la Red Hat OpenShift Container Platform.<\/p>\n
    Aqu\u00ed, disculpen, no podemos evitar decir: \u201c\u00a1OpenShift es maravilloso!\u201d<\/p>\n
    Inicialmente pensamos en escribir que el desarrollo en OpenShift no es diferente del desarrollo en Kubernetes. Y en esencia, as\u00ed es. Pero al escribir este post, recordamos cu\u00e1ntos pasos adicionales hay que dar cuando no tienes OpenShift, y por eso, lo repito, es maravilloso. Nos encanta cuando todo es f\u00e1cil, y la forma en que nuestro ejemplo se despliega y se ejecuta en OpenShift, en comparaci\u00f3n con minikube, es lo que nos motiv\u00f3 a escribir este post.<\/p>\n
    Vamos a recorrer el proceso y ver qu\u00e9 necesitamos hacer.<\/p>\n
    As\u00ed que, en el ejemplo de minikube comenzamos con Docker\u2026 Espera, ya no necesitamos que Docker est\u00e9 instalado en la m\u00e1quina.<\/p>\n
    Y no necesitamos git local.
    \nTampoco necesitamos Maven.
    \nY no hay necesidad de crear manualmente la imagen del contenedor.
    \nY no hay necesidad de buscar alg\u00fan repositorio de im\u00e1genes de contenedores.
    \nY tampoco hay que instalar un controlador de ingreso.
    \nY tampoco hay que configurar el ingreso.<\/b><\/p>\n
    \u00bfLo entienden, verdad? Para desplegar y ejecutar nuestra aplicaci\u00f3n en OpenShift, no es necesario nada de lo mencionado anteriormente. Y el proceso es el siguiente.<\/p>\n
    Paso 1 \u2013 Iniciamos nuestro cl\u00faster OpenShift<\/h4>\n
    \nUtilizamos Code Ready Containers de Red Hat, que es esencialmente lo mismo que Minikube, pero con un cl\u00faster OpenShift de un solo nodo completo.<\/p>\n
    crc start\n<\/code><\/pre>\n
    <\/p>\n
    Paso 2 \u2013 Realizamos la construcci\u00f3n y despliegue de la aplicaci\u00f3n en el cl\u00faster OpenShift<\/h4>\n
    \nEn este paso, la simplicidad y comodidad de OpenShift se manifiestan en todo su esplendor. Al igual que en todas las distribuciones de Kubernetes, tenemos muchas formas de iniciar una aplicaci\u00f3n en el cl\u00faster. Y, como en el caso de KUK, elegimos deliberadamente la opci\u00f3n m\u00e1s simple.<\/p>\n
    OpenShift siempre se ha construido como una plataforma para crear y ejecutar aplicaciones en contenedores. La construcci\u00f3n de contenedores siempre ha sido una parte integral de esta plataforma, por lo que aqu\u00ed hay un mont\u00f3n de recursos adicionales de Kubernetes para las tareas correspondientes.<\/p>\n
    Utilizaremos el proceso Source 2 Image (S2I) de OpenShift, que tiene varias maneras de tomar nuestro c\u00f3digo fuente (ya sea c\u00f3digo o archivos binarios) y convertirlo en una imagen de contenedor que se ejecute en el cl\u00faster de OpenShift.<\/p>\n
    Para esto, necesitaremos dos cosas:<\/p>\n