DevOps

Curso de arquitecturas monolíticas basadas en microservicios

Aprende a mezclar técnicas de Microservicios en servicios con arquitecturas monolíticas.

Impartido por:

4.3 (340 valoraciones)
4 horas y 1 minuto · curso
Arquitecturas monolíticas y microservicios

Lo que aprenderás en este curso:

  • Diseño monolítico.
  • Uso de metodologías de microservicios a monolíticos.
  • Despliegue en producción de forma ágil.

Requisitos del curso

Para hacer este curso de arquitecturas monolíticas basadas en microservicios, se aconseja tener experiencia en el desarrollo de aplicaciones.

Conocer Java te ayudará a entender mejor los ejemplos, se aconseja tener conocimientos básicos de Docker y Kubernetes.

 

Valoraciones de estudiantes:

  • 5
  • 4
  • 3
  • 2
  • 1
4.3
340 valoraciones

Contenido del curso:

    • 4 m
    • ¿Por qué microservicios?
      11 m
    • Ciclo de sobreexpectación
      4 m
    • Darwinismo digital
      7 m
    • Facilidades en monolítico
      7 m
    • 2 m
    • Aislando código
      9 m
    • Ejemplo de asilamiento de código
      4 m
    • Code-Assert y Modulos Java 9
      8 m
    • Ejemplo de Code-Assert
      7 m
    • Ejemplo aislamiento de las librerías. Enforcer y Shading
      9 m
    • Aislamiento de datos
      4 m
    • Flyway
      5 m
    • Ejemplo de aislamiento de datos
      8 m
    • Código reactivo
      7 m
    • RxJava
      6 m
    • Ejemplo de RxJava
      7 m
    • Acceso a elementos externos y patrón circuit-breaker
      8 m
    • Resilence4j
      5 m
    • Ejemplo de Resilence4j
      2 m
    • DevOps
      11 m
    • 4 m
    • Ejemplo de Docker
      5 m
    • Resiliencia y escalabilidad
      3 m
    • Kubernetes
      7 m
    • Ejemplo de Kubernetes
      2 m
    • Frabric8 FMP
      3 m
    • Ejemplo de Frabric8 FMP
      3 m
    • OpenShift
      6 m
    • Ejemplo de OpenShift
      7 m
    • Twelve Factor App
      9 m
    • Sacar el estado de un monolito
      4 m
    • Ejemplo de estado
      9 m
    • Blue-Green, Canary Release y Dark Launchers
      12 m
    • Migrando microservicios
      5 m
    • Conclusiones
      4 m
    • Stack Overflow
      3 m
También te puede interesar

Te dejamos una selección de cursos, carreras y artículos

Vagrant para desarrolladores

Curso de Vagrant para desarrolladores

2 horas y 58 minutos · curso

Aprende a mezclar técnicas de Microservicios en servicios con arquitecturas monolíticas.

  • Backend
Fundamentos Generales: Orquestación y Automatización IT

Fundamentos Generales: Orquestación y Automatización IT

46 minutos y 25 segundos · curso

Aprende a mezclar técnicas de Microservicios en servicios con arquitecturas monolíticas.

  • DevOps

Dudas frecuentes

1

¿Cuándo comienza el curso?

En OpenWebinars los cursos no tienen fecha de inicio y de final.

Cada curso tiene una fecha de publicación y desde ese día estarán 100% disponible todos los contenidos del curso para los usuarios suscritos a alguno de nuestros planes.

2

¿Cuál es el precio?

En OpenWebinars no vendemos cursos, talleres o laboratorios unitarios.

Tenemos diferentes tipos de suscripciones, que te dará acceso completo a todos los cursos de la plataforma y a los nuevos que vamos lanzando, siempre y cuando tu suscripción esté activa (como Spotify con la música o Netflix con las películas y series).

¿Eres una empresa? Tenemos planes especiales para ti. Consúltanos aquí.

3

¿Obtengo un diploma de certificación?

En todos los cursos existe un examen final para evaluar tus conocimientos adquiridos. Si superas este examen con más de un 80% de preguntas correctas obtendrás el diploma de certificación. Puedes realizar un intento cada 24 horas.

Este diploma es un certificado privado emitido por OpenWebinars, y valorado en el mundo empresarial, ya que tenemos grandes compañías clientes que se forman con nosotros y valoran nuestras certificaciones.

No olvides poner tu certificación en tu perfil Linkedin y en tu currículum.

Realizando este curso online serás capaz de desarrollar una arquitectura monolítica compuesta de microservicios, gracias a la formación que te proponemos durante el mismo.

Aprenderás en qué consisten los sistemas monolíticos, cuáles son sus componentes y procesos principales. También conocerás qué son los microservicios, cómo funcionan, cuáles son sus características, sus ventajas e inconvenientes y podrás desplegar de forma ágil y correcta tus desarrollos.

Para iniciar el curso el profesor ha preparado una introducción con la que ponerte en situación, tanto para saber quién es y por qué es el adecuado para impartir el curso, como de un resumen del temario que se irá viendo a continuación.

La introducción se completa con una primera toma de contacto con algunos fundamentos o conceptos como son los microservicios y su importancia en la actualidad, el ciclo de sobreexpectación, el darwinismo digital y las facilidades que aportan las arquitecturas monolíticas.

A continuación comenzaremos la parte teórica del curso, comenzando por un primer bloque dedicado al diseño de un monolítico usando tecnologías que se utilizan en microservicios, para aprovechar todas sus ventajas. Durante el mismo vamos a crear una aplicación paso a paso, la cual se irá desarrollando a lo largo de todas las lecciones del curso.

En esta sección comenzarás aprendiendo a separar el código de cada una de las partes de la aplicación, para que estén aisladas unas de otras. Además podrás ver cómo realizar de una forma automática el aislamiento del código, utilizando proyectos como Code-Assert o Jigsaw, dependiendo de la versión de Java que se esté empleando. Tras la parte teórica comenzaremos a crear nuestra aplicación de prueba, para aplicar lo explicado previamente.

Una vez hayas aprendido cómo aislar el código de la aplicación, pasamos a desarrollar la formación centrada en el aislamiento de los datos entre partes de la aplicación. Para ello hay que crear esquemas en la base de datos, uno por cada módulo existente. Te mostraremos cómo crear esos esquemas y cómo actualizarlos de forma automática utilizando la herramienta Flyway, primero de forma teórica y después realizando el proceso en nuestra aplicación de prueba.

Continuaremos con la lección en la que detallaremos como algunos frameworks o paradigmas de programación usados en microservicios se pueden utilizar también en monolíticos. Aquí conocerás qué es el código reactivo, para qué se utiliza y qué ventajas aporta. Además vas a poder utilizar RxJava para crear ese código reactivo para continuar con el desarrollo de nuestra aplicación.

La siguiente lección te permitirá adquirir los conocimientos necesarios para hacer que la comunicación entre nuestra aplicación y elementos externos se realice de forma correcta, utilizando el patrón Circuit Breaker, en este caso una de sus implementaciones Java, denominada Resilence4j. Al finalizar volveremos a aplicar todo lo que hemos visto en la lección en la aplicación que estamos creando durante el curso.

Finalizada esta primera sección del curso, podrás pasar a la siguiente, dónde vas a poder ver cómo realizar el despliegue de un monolítico. Este es un bloque bastante extenso y que está dividido también en varias lecciones para que puedas aprender de forma detallada y paso a paso todo este proceso.

Estas lecciones comenzarán con una primera en la que el tutor hablará de la importancia de adoptar la metodología DevOps, introduciendo primero este concepto y detallando después qué ventajas aporta y cómo implementarla en los desarrollos de forma correcta.

Una vez contextualizado el marco para el despliegue de monolíticos, hablaremos sobre Docker, explicaremos de forma básica los fundamentos de esta tecnología, para qué sirve y la importancia que tiene dentro de este proceso que estamos desarrollando. Después de la teoría entramos en la fase de ejecución de la misma para seguir con nuestra aplicación, para la cual vamos a generar una imagen Docker.

El siguiente paso en tu formación será conocer y comprender los conceptos de resiliencia y escalabilidad, y los problemas relacionados con los mismos que se producen al utilizar Docker. Para solventarlos utilizaremos Kubernetes, un orquestador de contenedores que permite hacer escalables y resilientes las aplicaciones al utilizar Docker.

De forma resumida explicaremos los fundamentos de Kubernetes, su funcionamiento, estructura y principales conceptos. Acabada la parte teórica volveremos a retomar la aplicación que estamos creando para desplegarla en Kubernetes.

Continuaremos detallando cómo poder crear y desplegar contenedores en Kubernetes de forma más rápida y automatizada, para ello utilizaremos varias herramientas, como Fabric8 Maven Public y OpenShift. Tras explicar las mismas, pasaremos a utilizarlas en el despliegue de nuestra aplicación.

Para acabar esta sección introduciremos la metodología Twelve Factor App, empleada para construir aplicaciones SASS, y que permite que el despliegue y escalado de las mismas sea óptima. Detallaremos las doce reglas de las que se compone y cómo conseguir aplicar una de las más importantes, como es que nuestra aplicación no tenga estado, lo que haremos con un grid a memoria.

El penúltimo apartado del curso verás algunas técnicas para realizar el lanzamiento de servicios en arquitecturas basadas en microservicios. Destacaremos tres técnicas de todas las existentes, en concreto Blue-Green, Canary Release y Dark Launchers, explicando cada una de ellas para que comprendas su funcionamiento y diferencias.

Concluiremos el curso desarrollando unos pasos finales y conclusiones a tener en cuenta en el diseño de una arquitectura monolítica compuesta de microservicios, además veremos un ejemplo real de un monolítico que funciona perfectamente, como es Stack Overflow.

Las cookies nos permiten ofrecer nuestros servicios. Al utilizar nuestros servicios, aceptas el uso que hacemos de las cookies. Más Información.