Una opción popular de arquitectura de alto nivel en un programa moderno es un sistema de microservicios basado en REST. Esto tiene varias ventajas, como acoplamiento flojo, reutilización fácil, restricción limitada de tecnologías que se pueden usar, alta escalabilidad, etc.
Pero uno de los problemas que preveo en dicha arquitectura es la poca visibilidad de cuáles son las dependencias de una aplicación. Por ejemplo, supongamos que tengo una aplicación que utiliza un conjunto de llamadas REST a diario. Esta aplicación también utiliza un segundo conjunto de llamadas REST, pero solo una vez por trimestre. Si escaneara los registros de la última semana, vería todas las llamadas diarias, pero probablemente no vería las llamadas trimestrales. Cuando llega el momento de refactorizar, las llamadas trimestrales tienen un alto riesgo de ruptura.
¿Qué patrones o herramientas se pueden usar para reducir este riesgo y proporcionar una mayor visibilidad de cuáles son las dependencias de una arquitectura débilmente acoplada?
fuente
Respuestas:
Mantener sus API y sus capacidades comerciales compatibles con versiones anteriores.
Controles de salud.
Mi servicio es un cliente para su capacidad de API mensual. Pero mi servicio es el cliente de su API cada vez que mi servicio se está ejecutando. Por lo tanto, mi servicio se activa cada 10 minutos, o lo que sea, se conecta a su API mensual y ejecuta el protocolo para asegurarse de que la capacidad que necesita mi servicio aún esté disponible.
Por lo tanto, sus registros le mostrarán con qué frecuencia algún otro servicio está verificando para ver si cada servicio en particular que ofrece todavía está disponible, al igual que le muestra con qué frecuencia se utiliza cada servicio en particular que ofrece.
fuente
Hay al menos dos ubicaciones donde puede encontrar las dependencias:
Configuración. El acceso a API externas requiere conocer mucha información sobre cada una de esas API. ID de acceso, claves secretas, puntos finales. Todo esto no puede ser en el código, ya que tal información será cambiar. Como ejemplo, recientemente comencé a migrar todos mis microservicios a SSL. Esto significa que cada servicio que se basa en el que se está migrando debe reconfigurarse para que apunte a la
https://versión en lugar dehttp://. Me alegra que los puntos finales estuvieran en la configuración en lugar de estar codificados.Interfaces No accede a un servicio directamente desde su código, porque la versión de la API cambiará, e incluso puede decidir cambiar a una API diferente. En su lugar, crea una capa de abstracción y utiliza la dependencia a través de una interfaz. Al seguir una lógica común al crear esas interfaces, puede facilitarle la vida más adelante cuando busque las dependencias.
Para eso es la prueba de regresión.
No puede simplemente mirar el código, cambiarlo y confiar en sí mismo de que nada se rompió. Esto no funcionará en una arquitectura de microservicios. Esto tampoco funcionará en una aplicación monolítica. Un compilador puede detectar algunos de los errores que introducirá al modificar el código. En algunos idiomas, como Haskell, el compilador puede ser muy capaz y detectar la mayoría de los errores; Sin embargo, los compiladores para los idiomas principales no harán mucho por usted. Si no tienes pruebas, estás jodido. La presencia de microservicios es irrelevante.
fuente
Las API REST se especifican en términos generales, por lo que en algún momento puede ser útil pasar a gRPC, google protobufs o Thrift para definir una interfaz RPC y luego versionarla.
fuente