Creación de su primer microservicio con Swagger y .NET Core

Por qué Optimove pasó de un sistema monolítico a uno basado en microservicios, además de un tutorial para crear un microservicio por tu cuenta.

Tiempo de lectura 7 minutos

LinkedInXFacebook

Informe exclusivo de Forrester sobre la IA en el marketing

En Optimove, estamos cambiando nuestra arquitectura de monolítica a microservicios.

¿Por qué estamos llevando a cabo esta transición? Nuestra motivación proviene del deseo de implementar y entregar pequeños fragmentos de código a producción, sin depender de otros componentes o equipos. De este modo, los ciclos serán mucho más cortos y la calidad, mucho mayor.

Actualmente utilizamos .Net Core, Swagger y Docker para esta tarea. En esta entrada del blog, abordaremos algunos conceptos básicos que te ayudarán a crear una API utilizada como microservicio, utilizando .Net Core.

Crearemos una API básica con una respuesta personalizada.

Pero retrocedamos un momento: ¿qué es un microservicio? ¿Y por qué queremos crear uno?

¿Qué son los microservicios?

Para ayudarle a comprender el concepto, he publicado algunas citas sobre los microservicios a continuación:

«Un método distintivo de desarrollo de sistemas de software que intenta centrarse en la creación de módulos de una sola función con interfaces y operaciones bien definidas» (Smarbear).

«Un microservicio es una pieza autónoma de funcionalidad empresarial con interfaces claras y que, a través de sus propios componentes internos, puede implementar una arquitectura por capas» (Wikipedia).

¿Por qué utilizar microservicios?

Los microservicios tienen varias ventajas. Son:

  • Fáciles de implementar
  • Fáciles de escalar
  • Fáciles de entender
  • Fáciles de encontrar (y aislar) errores.
  • Débilmente acoplados.
  • Comprobables.

Y muchas más.

Por supuesto, los microservicios tienen algunas desventajas:

  • Requieren cambios culturales y no son compatibles con versiones anteriores.
  • Existen retos de seguridad debido a la comunicación entre servicios en todo el sistema.

Dos herramientas populares que nos ayudarán a crear nuestro microservicio son Docker y Swagger. Profundicemos en ambas.

Docker

«En términos sencillos, Docker es una plataforma de software que simplifica el proceso de creación, ejecución, gestión y distribución de aplicaciones. Lo hace virtualizando el sistema operativo del ordenador en el que está instalado y se ejecuta». (FreeCodeCamp)

«Docker es una herramienta diseñada para facilitar la creación, implementación y ejecución de aplicaciones mediante el uso de contenedores. Los contenedores permiten a los desarrolladores empaquetar una aplicación con todos los componentes que necesita, como bibliotecas y otras dependencias, y enviarla como un solo paquete». (Noteworthy)

Swagger

Swagger es el ecosistema de herramientas más utilizado para desarrollar API con la especificación OpenAPI (OAS). Swagger consta de herramientas tanto de código abierto como profesionales, que satisfacen casi todas las necesidades y casos de uso.

Básicamente, Swagger es ideal para la documentación de API, las pruebas y la creación de proyectos de servidor en el lenguaje que elijas, así como proyectos SDK de cliente.

Este ejemplo lo aclarará :

Documentación de API:

Prueba de la API a través de la cómoda interfaz de usuario:

Una vez que haya diseñado su API, puede generar tanto el código del servidor como el del cliente para empezar.

En un enfoque denominado «diseño primero», se comienza con el diseño de la API y se genera el código a partir del diseño.

Pero, ¿qué ocurre si desea escribir primero el código y luego crear la documentación Swagger?

El enfoque «código primero» es la ruta más tradicional. Una vez que la API está directamente codificada, puede generar un documento Swagger utilizando diferentes herramientas, como Swashbuckle.

Ahora, combinemos las herramientas anteriores y creemos un microservicio básico utilizando el enfoque Design-First.

Comencemos por crear una API sencilla generada desde Swagger. Una vez que abra un editor Swagger, hay varias opciones:

1. https://editor.swagger.io/

Cree una cuenta en https://app.swaggerhub.com

Utilice el complemento Swagger para Visual Studio Code (ctrl+shift+p editor Swagger)

2. He creado una API muy básica con 3 llamadas y 2 módulos:

Este es el código YAML:

*swagger: "2.0"
info:
description: "This is a demo for a basic micro service"
version: "1.0.0"
title: "Micro-Service demo"
termsOfService: "http://swagger.io/terms/"
contact:
email: "rima_g@optimove.com"
license:
name: "Apache 2.0"
url: "http://www.apache.org/licenses/LICENSE-2.0.html"
host: "dummy-api.com"
basePath: "/v2"
tags:

  • name: "actors"
    description: «Datos sobre actores»
    documentos externos:
    descripción: «Más información»
    url: «http://swagger.io»
  • nombre: «películas»
    descripción: «Datos sobre películas»
  • nombre: «estado»
    descripción: «Estado de la API»
    esquemas:
  • «https»
  • «http»
    rutas:
    /actores:
    publicación:
    etiquetas:
  • «actores»
    resumen: «Añadir un nuevo actor»
    descripción: «»
    operationId: «addActor»
    consume:
  • «application/json»
    produce:
  • «application/json»
    parámetros:
  • en: «cuerpo»
    nombre: «cuerpo»
    descripción: «Objeto actor que debe añadirse a la base de datos»
    requerido: verdadero
    esquema: $ref : «#/definitions/Actor»
    respuestas:
    405:
    descripción: «Entrada no válida»
    /actors/{actorId}:
    obtener:
    etiquetas:
  • «actors»
    summary: «Buscar actor por ID»
    description: «Devuelve un único actor»
    operationId: «getActorsById»
    produces:
  • «application/json»
    parámetros:
  • nombre: «actorId»
    en: «path»
    descripción: «ID del actor que se va a devolver»
    obligatorio: verdadero
    tipo: «entero»
    formato: «int64»
    respuestas:
    200:
    descripción: «operación correcta»
    esquema:
    $ref: «#/definitions/Actor»
    400:
    descripción: «ID no válido»
    404:
    descripción: «Actor no encontrado»
    seguridad:
  • api_key: []
    /status:
    get:
    etiquetas:
  • «status»
    summary: «devuelve el estado de la API»
    description: «Devuelve un único actor»
    operationId: «getStatus»
    produces:
  • «application/json»
    responses:
    200:
    description: «La API está bien»
    schema: $ref : «#/definitions/ApiStatus»
    404:
    description: «API no encontrada»
    security:
  • api_key: []
    securityDefinitions:
    imdb_auth:
    type: «oauth2»
    authorizationUrl: «http://imdb.swagger.io/oauth/dialog»
    flow: «implicit»
    scopes:
    write:imdb: "modificar películas y actores en tu cuenta"
    read:imdb: "leer los datos de tus películas y actores"
    api_key:
    tipo: "apiKey"
    nombre: "api_key"
    en: "header"
    definiciones:
    ApiStatus:
    tipo: "objeto"
    propiedades:
    mensaje:
    tipo: «cadena»
    descripción: «Estado de la API»
    Actor:
    tipo: «objeto»
    obligatorio:
  • «id»
  • «nombre»
  • «apellidos»
    propiedades:
    id:
    tipo: «entero»
    formato: «int64»
    nombre:
    tipo: «cadena»
    ejemplo: «Ryan»
    apellido:
    tipo: «cadena»
    ejemplo: «Gosling»
    xml:
    nombre: «Actor»
    documentos externos:
    descripción: «Más información sobre Swagger»
    url: «http://swagger.io»*

Así es como se ve:

3. Haz clic en «Generar servidor» y selecciona el lenguaje que prefieras para exportar el stub del servidor:

Yo elegí aspnetcore, pero, por supuesto, puede elegir cualquier idioma.

4. Utilizando la línea de comandos, vaya a la carpeta del proyecto y ábrala en Visual Studio Code, utilizando el comando «code .».

5. Vaya a /src/IO.Swagger/Controllers/StatusApi.cs

Fíjate en este método:

Cambiemos la respuesta por algo más personalizado:

public virtual IActionResult GetStatus()
{
//TODO: Descomente la siguiente línea para devolver la respuesta 200 o utilice otras opciones como return this.NotFound(), return this.BadRequest(..), …
ApiStatus res= new ApiStatus();
res.Message="¡El cuaderno es genial y la API está activa!";
return StatusCode(200, res);
{

6. Abra Terminal (Terminal->Nueva terminal) o CTRL+Mayús+' y ejecute el comando de compilación: donet build

Ahora, veamos el archivo Dockerfile. Lo encontrarás aquí:

Para crear una imagen, debemos ejecutar el archivo Docker:

Cd src/IO.Swagger/

A continuación, ejecuta el comando de compilación:

docker build -t imdb-demo:1.0.0 -f Dockerfile .

O, si no tienes permisos suficientes:

sudo docker build -t imdb-demo:1.0.0 -f Dockerfile .

«imdb-demo» representa el nombre de la imagen.

1.0.0 es la etiqueta, que suele especificar la versión.

7. Echemos un vistazo a las imágenes. Utilice este comando:

sudo docker images

8. Ejecute la imagen de Docker para poder acceder a la API a través de localhost:

Vuelva al código de Visual Studio y escriba:

sudo docker run -d -p 3003:80 --name imdblocal imdb-demo:1.0.0

Hemos elegido el puerto 3003 para acceder a la API.

«Imdblocal» es el nombre de esta instancia concreta.

9. Vamos a localhost/3003

Haga clic en /status:

Y luego en «¡Pruébelo!».

Esta es la respuesta personalizada que escribimos.

También podemos acceder a ella con esta URL:

Localhost:3003/v2/status

Código primero

Si aún desea utilizar el enfoque de código primero (si ya tiene un código API listo o simplemente prefiere escribirlo desde cero), puede utilizar una herramienta que le ayude a generar la documentación Swagger de su API.

La lista completa de estas herramientas se puede encontrar aquí.

Para .Net Core, utilicé Swashbuckle.

Resumen

Con Swagger y .Net Core, hemos aprendido a crear fácilmente un proyecto API básico. Hemos creado una imagen Docker y la hemos ejecutado para poder acceder a nuestro servicio a través de localhost. ¡Estén atentos, la próxima vez hablaremos de la implementación en producción!

Informe exclusivo de Forrester sobre la IA en el marketing

En este informe exclusivo de Forrester, descubra cómo los profesionales del marketing global utilizan la inteligencia artificial y el marketing sin posiciones para optimizar los flujos de trabajo y aumentar la relevancia.

Optimove Team of Authors

El equipo de redactores de Optimove incluye expertos en marketing, I+D, productos, ciencia de datos, éxito de clientes y tecnología que desempeñaron un papel fundamental en la creación del Positionless Marketing, un movimiento que permite a los profesionales del marketing hacer cualquier cosa y ser cualquier cosa.

La diversa experiencia y los conocimientos prácticos de los líderes de Optimove proporcionan comentarios expertos y perspectivas sobre prácticas y tendencias de marketing probadas y de vanguardia.

Aprende más, sé más con Optimove.
Consulta nuestros recursos
Descubrir
Únete al movimiento del Positionless Marketing
Únete a los profesionales del marketing que están dejando atrás las limitaciones de los roles fijos para aumentar la eficacia de sus campañas en un 88 %.