DEV Community: Eezze

Deploy with Eezze

Rolf Streefkerk — Tue, 16 Apr 2024 12:33:17 +0000

In this showcase of Eezze, we'll cover how we save time with our deployment automations:

1. The Deployment Headache
2. Seamless Deployment
3. Tutorial
4. Frequently Asked Questions
5. Beyond the Basics
6. Conclusion

1. The Deployment Headache

In the realm of software development, deploying backend applications often presents a significant challenge. Developers find themselves grappling with the intricate tasks of configuring servers, ensuring dependencies are correctly installed, and maintaining complex deployment scripts. These essential yet time-consuming processes can divert valuable resources away from core development efforts, impeding productivity and slowing down the overall software delivery pipeline.

At Eezze, we understand these challenges intimately. Our platform leverages industry-standard tooling such as Ansible for configuration management, Terraform for infrastructure provisioning, and Docker containers for consistent application environments. By automating and streamlining the deployment process, Eezze eliminates the hassle, allowing teams to concentrate on building exceptional solutions.

2. Seamless Deployment

With Eezze, we aim to transform the deployment experience, making it seamless and effortless. In this article, we'll walk you through the process of deploying backend applications using Eezze's platform, demonstrating how our solution automates complex tasks and ensures a smooth, hassle-free workflow.

3. Tutorial

Steps:

Set up a Connection in Eezze, currently we support Ubuntu 22.04 Server and AWS Cloud deployments.

For a Ubuntu 22.04 Server, we define the server host configuration in the Connection Info tab, and then in the Authentication tab we configure the SSH connectivity (PEM Key) and User/Password for SuperUser access.

Create your datasources, which are basically servers internally (linked to a Connection) or externally hosted servers and services;
Configure a REST Server, for example; the host has already been filled in, since this is an internal service (it can be customized) Additionally a health check port is auto-configured to ensure keep-alive in Application Load Balancer scenario's functions properly:
Entity definitions for your Database Datasource will be automatically applied as migrations at the docker-compose REST server entrypoint, enabling up-to-date synchronization of your data model with your database(s):
Environment Variables and Vault (protected) variables are automatically applied to your containers for run-time use:
Add your Services in our Service Group > Services editor.
Deploy to your empty Ubuntu 22.04 Server instance or a Connection with AWS Account credentials configured in the Authentication section in step (1).

We offer these public, and private cloud/server compatible solutions:

Ubuntu 22.04: we use an Ansible playbook to install a complete environment that is ready to be used for Docker container deployment, then build and deploy the containers from a Github repository.
AWS ECS: we've build a custom pipeline that interprets your project configuration, applies that our Terraform script that can interpret our project configution exactly, and deploy all Docker Containers via AWS CodePipeline/CodeBuild to ECS Fargate. These Containers are load balanced with AWS ALB (Application Load Balancer) which terminates the SSL and enables custom domains to be easily linked using AWS Route53 such as; https://api.yourapp.com.

4. Frequently Asked Questions

Q: How does your company use Eezze for client projects?

A: Eezze is our proprietary in-house tooling that streamlines the development and deployment of backend solutions. While the Eezze platform itself is not directly accessible to clients, we leverage its capabilities to generate the necessary artifacts for your projects, such as Git repositories, Docker files, Ansible playbooks, and source code.

Q: What kind of artifacts and deliverables can we expect from your use of Eezze?

A: By utilizing Eezze, we can provide you with a comprehensive set of artifacts tailored to your project requirements. These may include a fully configured Git repository with your application's source code (Typescript), Docker containers for consistent and isolated environments, Ansible playbooks for automated deployments, and any other necessary configuration files or scripts.

Q: Can you handle deploying our application to our existing infrastructure?

A: Absolutely. In addition to providing the generated artifacts, we can also leverage our Eezze automations to deploy your application directly to your existing infrastructure or environment. Our team can work closely with you to understand your infrastructure requirements and ensure a seamless deployment process, whether it's on-premises or in the cloud.

Q: Can we customize or modify the generated artifacts from Eezze?

A: Absolutely. While the Eezze platform itself is proprietary, the generated artifacts, such as source code and configuration files, are fully accessible and customizable by your team. The only proprietary code is the Eezze plugin, which is used to enhance the capability of our code automations. We encourage collaboration and can work closely with you to make any necessary modifications or enhancements to the deliverables.

Q: How do you handle updates and maintenance for the generated artifacts and deployed applications?

A: As part of our ongoing support and maintenance, we can provide regular updates and enhancements to the generated artifacts and deployed applications. This may include bug fixes, security patches, or new features based on your evolving project requirements. Our team will work closely with you to ensure a seamless update and deployment process.

Q: Can we integrate the generated artifacts and deployed applications with our existing infrastructure and tooling?

A: Yes, the artifacts generated by Eezze and the deployed applications are designed to be compatible and easily integrated with a wide range of infrastructure and tooling. Whether you have existing deployment pipelines, monitoring systems, or other tools in place, we can ensure a smooth integration process, minimizing disruptions to your existing workflows.

5. Beyond the Basics

Eezze's advanced internal tooling brings significant benefits to customers, particularly in the areas of deployment automation and speed.

AWS Deployment Excellence

Eezze's AWS ECS deployment automation integrates a custom pipeline and Terraform scripting for precise interpretation of project configurations. Key features include:

Custom Pipeline & Terraform: Interprets project configurations accurately for Docker Container deployment on ECS Fargate.
AWS CodePipeline/CodeBuild: Automates deployment workflows for faster time-to-market.
AWS ALB Load Balancing: Ensures scalability and reliability with SSL termination and custom domain integration using AWS Route53.

This streamlined deployment approach optimizes efficiency, accelerates deployment cycles, and enhances the security and scalability of your applications on AWS ECS.

Global Reach with Ubuntu 22.04

Eezze's automation extends globally to servers running Ubuntu 22.04, delivering rapid deployment benefits to customers. By automating the setup of all required software for a Docker container platform, Eezze accelerates deployment speed and ensures consistency across customer environments, leading to increased efficiency and reduced time-to-deployment for customer projects.

6. Conclusion

Eezze's internal tooling directly benefits customers by:

Accelerating deployment timelines through advanced automation capabilities.
Ensuring seamless integration with customers' existing infrastructure, minimizing disruptions and maximizing operational efficiency.
Providing access to cutting-edge deployment solutions, such as AWS integration and global deployment automation, resulting in faster time-to-market and increased competitiveness for customer solutions.

Ready to experience the speed and efficiency benefits of Eezze's internal tooling for your deployments? Request a personalized demo or quote today and discover how Eezze can transform your deployment experiences and deliver superior results for your projects.

Build Real-Time Apps with Eezze

Rolf Streefkerk — Tue, 02 Apr 2024 03:38:17 +0000

Build Real-Time Apps with Eezze

Here's a quick overview of what we'll cover in this showcase of Eezze's Websocket functionality:

Introduction
Streamlining Websocket Integration with Eezze's UI-Based Approach
- The Power of Actions
- Harnessing the 6 Directives
- Building Blocks to Backend
Practical Showcase: Eezze in Action
- 1. Dynamic Template Rendering
- 2. Stream Logging Data
- Generated Code (For Advanced Understanding)
Unlocking Real-Time Potential
Conclusion

Introduction

Frustrated by the complexities of implementing real-time features in your applications? Eezze offers a streamlined solution, empowering developers to build responsive, data-driven apps without diving deep into websocket protocols and synchronization code.

Eezze's low-code approach doesn't sacrifice control. Our platform recognizes that events are the lifeblood of any interactive application. Our UI lets you precisely configure how your app reacts to user interactions, data updates, and connection changes.

At its core, Eezze provides a set of directives for event handling. Imagine setting up a collaborative workspace feature with a simple configuration like "on message update, broadcast to channel subscribers."

In this article, we'll explore Eezze's event-driven workflow and build a real-time backend. You'll experience how Eezze's UI-based logic accelerates development of features that traditionally require extensive coding.

Streamlining Websocket Integration with Eezze's UI-Based Approach

Configure a websocket connection by specifying the server endpoint within a dedicated interface. You'll then define individual websocket event types, configuring custom "Actions" for each of the 6 supported directives.

The Power of Actions

Actions form the backbone of service development in Eezze, extending to websockets, REST APIs, and scheduled tasks. These sequential blocks handle data input, processing, and output. Within an Action block, you can:

Query databases
Manipulate files
Manage email communication
Generate output using the Twig templating language
Integrate with third-party services via REST or Websocket APIs

Harnessing the 6 Directives

Eezze puts control in your hands with these directives for building event-driven websocket backends:

on (event specification): Define the precise trigger for an action within your application (e.g., "on new message").
broadcast (send to everyone): Distribute data to all connected users when the associated "on" event occurs.
channel (send to only those that meet channel criteria): Target communication to specific user groups within your application.
notify (notification to a specific connection or user): Send targeted notifications to individuals.
onConnect: Execute actions when a user establishes a connection.
onDisconnect: Define responses triggered when a user disconnects.

Building Blocks to Backend

Each directive, combined with custom input definitions, Actions, and output configurations, acts as a modular building block. This allows you to assemble a robust websocket backend tailored to your application's specific needs.

Practical Showcase: Eezze in Action

To demonstrate the power of Eezze's websocket integration, let's explore two use cases that we have used websockets for in our upcoming app developed with Eezze:

Dynamic Template Rendering

Goal: Update a user profile page in real-time whenever the profile data is modified.

Steps:

Create Service Group: Establish a Service Group connected to your Websocket Datasource (Websocket Container Service configuration).
Configure 'On' Service: Within the group, create a new websocket service using the "On" event type triggered by a "render-profile" event.
Define Actions: Set up the following Actions within the service:
- Action 1: Retrieve the updated profile data from your database ("Get One" from Profile table, Check On parameters 'copied' from the Action Chain Input).
- Action 2: Render the profile HTML using a stored Twig template. Provide input mapping from Action 1.

Result: The "render-profile" event triggers the service, updating the profile page with the latest data.

Stream Logging Data

Goal: Send real-time logging updates to a designated channel for monitoring.

Steps:

Configure Channel Service: Create a websocket service using the "Channel" directive. Provide an ID to identify the configuration and set up the specific channel name (e.g., pr.${adm.input.projectId}).
Set Up Broadcast Service: Create a second service using the "Broadcast" event linked to the log event. The Action Chain Input defines projectId and data for the logging packet. The only Action emits this data.

Result: Applications subscribed to the defined channel receive real-time logging updates. Eezze itself uses this functionality.

Generated Code (For Advanced Understanding)

For those curious about the underlying code that powers Eezze's websocket functionality, let's examine the Channel and Broadcast example in more detail.

Websocket Controller (controller.ws.ts)

Eezze leverages decorators in TypeScript to streamline websocket service configuration:

@Channel({
  id: 'project-logging-channel',
  channel: async (adm: ADM, lc: LogicChain) => {
    // Action 1 - Logic item '0'
    lc.text.custom(() => {
      return `pr-${adm.input.projectId}`;
    });

    // evaluate the result and then return the result
    return await lc.result();
  }
})
async projectLoggingChannel() {}

@Broadcast({
  event: 'log',
  channel: async (adm: ADM, lc: LogicChain) => {
    // Action 1 - Logic item "0"
    lc.text.custom(() => {
      return `pr-${adm.input.projectId}`;
    });

    // evaluate the result and then return the result
    return await lc.result();
  },
})
async projectLogs() {}

Broadcast Service Code (action.ts)

The Broadcast Service itself demonstrates Eezze's focus on readability and efficiency:

// Send data packet to Channel
@Do({
  run: async (adm: ADM, lc: LogicChain) => {
    // Action 1 - Logic item "0"
    lc.text.custom(() => {
      adm.setResult(adm.input?.data);
      return 'success';
    });

    // evaluate the result and then return the result
    return await lc.result();
  },
})
async _exec() {}

Unlocking Real-Time Potential

Eezze's UI-based approach isn't limited to the examples we've explored. Here are a few more ideas that can be quickly realized with Eezze.

Application Type	Key Features	How Eezze Simplifies Development
Collaborative Whiteboard	Live drawing, shapes, annotations, multiple users	`on` events map directly to user actions, `broadcast` updates the view
Data Visualization Dashboard	Real-time updating charts, graphs based on data streams	`on` data arrival triggers processing, updates pushed to clients
Workflow Automation Monitor	Visualize progress of complex workflows, track status changes, send notifications	`on` workflow events trigger updates and notifications, `channel` could be used for team-specific views

Key Point: Eezze enables developers to focus on the core interactions of their application rather than the complexities of managing real-time data flow.

Conclusion

Building real-time features has traditionally been a time consuming task, requiring specialized coding expertise that can slow down even the most agile development teams. Eezze transforms this process, enabling you to harness the power of websockets through a simple, event-driven UI.

With Eezze, you focus on defining how your application should respond to user actions, data changes, and external events. The complexities of websocket management and synchronization are handled for you.

Ready to see Eezze in action and how it can revolutionize your development workflow? Contact us on Eezze.io or find us on LinkedIn