Build Microservices Apps with Functions

Adopting a serverless microservices architecture with Azion Functions brings several significant benefits in this context. Firstly, it improves scalability by allowing each service to scale independently based on its own demand, rather than scaling the entire application based on the demand of a single service. This leads to more efficient resource utilization and cost savings.

Additionally, it enhances flexibility by allowing each service to be developed, deployed, and updated independently. This means that changes can be made to one service without impacting the others, enabling faster innovation and reducing the risk of system-wide failures.

Architecture

Dataflow

1. A user sends a request to the Domain associated with an application. This request is directed to the Azion Traffic Router, which identifies the appropriate Edge Node to process the request.

2. At this stage, based on microservice architecture, the request branches out to different services in response to the Rules Engine configuration. This branching out means the services can evolve independently, facilitating faster innovation cycles and quick deployment of new features.

3. Functions are invoked. Each service in a microservices architecture corresponds to different business capabilities. For example, an Authentication Middleware service handles user authentication, a Shopping Cart service manages user cart operations, and a Shipping Calculation service computes shipping costs. These services are developed in Javascript, deployed, and scaled independently, providing agility and resilience.

4. Static content gets saved in Object Storage from where it’s fetched and served as a response. This leverages edge computing to ensure lower latency and faster content delivery.

5. SQL Database handles operations involving database transactions. This further emphasizes the separation of concerns, with every service taking ownership of its specific database to ensure loose coupling and high cohesion.

After these distinct yet cohesive processes, the content —processed and assembled— is delivered back to the client. This microservices-oriented data flow with edge computing ensures highly efficient, scalable, and resilient operations, offering considerable business advantages.

Components

• Applications: set up an application to configure delivery and cache policies, create rules to automate cache policy assignments based on content type, and determine how content is cached.
  • Functions: allows you to create event-driven, serverless applications, at the edge of the network, closer to users.
  • Object Storage: a scalable and secure storage service designed to integrate object storage with the Azion Web Platform using the S3 standard for object operations.
  • SQL Database: an edge-native SQL solution designed for serverless applications. It’s fully ACID-compliant and utilizes SQLite’s SQL dialect to provide a familiar development environment, facilitating fast integration.

Implementation

1. Create an application:
   • On Console, create an application using the + Create button on the homepage.

• Using the Azion API to create an application.
• Using the Azion CLI to create and deploy an application.

2. Create a function and instantiate it in the recently created application.
3. Create a domain and associate it with the application:
   • On Console, create a domain using the + Create button on the homepage.
   • Using the Azion API to create a domain.
   • If you created an application through a template, the domain is created for you.

4. Test and monitor your application.

Related docs

• Azion Marketplace
• Azion Runtime Web APIs compatibility
• Azion Runtime Node.js compatibility