https://github.com/ewolff/SCS-ESI

Demo for Self-contained Systems (SCS) using ESI (Edge Side Includes) with Varnish for Frontend Integration
https://github.com/ewolff/SCS-ESI

Last synced: 9 days ago
JSON representation

Demo for Self-contained Systems (SCS) using ESI (Edge Side Includes) with Varnish for Frontend Integration

• Host: GitHub
• URL: https://github.com/ewolff/SCS-ESI
• Owner: ewolff
• License: apache-2.0
• Created: 2016-05-28T22:23:25.000Z (about 8 years ago)
• Default Branch: master
• Last Pushed: 2023-05-24T17:08:47.000Z (about 1 year ago)
• Last Synced: 2024-03-07T16:58:06.729Z (4 months ago)
• Language: Java
• Size: 359 KB
• Stars: 40
• Watchers: 7
• Forks: 15
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Lists

• awesome-architecture - github / ewolff / scs-esi - Example: Frontend integration for Self Contained Systems using Varnish. (Microservice and Self Contained Systems Architecture / Web Links on Microservice and SCS Architecture)

README

        
SCS ESI Sample

==============

[Deutsche Anleitung zum Starten des Beispiels](WIE-LAUFEN.md)

For [Self-contained Systems](http://scs-architecture.org) multiple

frontends need to be integrated. This sample shows how to do

this. Varnish serves as a cache and also ESI (Edge Side Includes) are

used to integrate multiple backends into one HTTP site.

This project creates a Docker setup with the complete systems based on

Docker Compose and Docker Machine. The services are implemented in

Java using Spring and Spring Cloud.

It uses two very simple SCS:

- Order to enter orders.

- Catalog to handle the items in the catalog.

How To Run

----------

See [How to run](HOW-TO-RUN.md) for details.

Remarks on the Code

-------------------

The SCS are: 

- [scs-demo-esi-common](scs-demo-esi-common) provides web assets and common headers

and footers for services. The microservice is written in Go and therfore has a small

footprint. It uses Multi Stage Docker containers to compile the Go program in one Docker

image and then copy over the result into a separate Docker image.

- [scs-demo-esi-order](scs-demo-esi-order) does order processing. It outputs

  `esi:include` in its HTML files to include the HTML snippets of

  `scs-demo-esi-common`. These are interpreted by the Varnish web

  cache. This microservices is written in Java. It has an Java main application

  in [src/test/java](https://github.com/ewolff/SCS-ESI/tree/master/scs-demo-esi-order/src/test/java/com/ewolff/microservice/order)

  to run the microservice stand alone with some test data. However, the layout

  of the web page will be incomplete because the ESI includes are not handled.

Varnish interprets the ESIs. The `default.vcl` in the directory

  `docker/varnish` includes the configuration to enable this. It

  defines two backends - one for each SCS. HTTP requests to `/catalog`

  are mapped to the catalog SCS while the default is the order

  SCS. The time to live for each item in the cache is 30s i.e. after

  30 seconds an entry in the cache in invalidated and the call goes to

  the backend. The grace is 15m: Even if the entry in the cache is

  invalid it will be served for 15 more minutes of the backend is not

  accessible. So if the backend crashes the cache can still provide

  some resilience.

Architecture Disclaimer

-------------------

This is a technology demo. The coupling between the two components in

this case is very tight - the integration is providing rather small

components that are embedded in specific pages. In a real world

architecture this should not be the case. Please refer to

http://scs-architecture.org/ to better understand the architecture

this should support.