Containerize Monorepo Apps with Docker and DigitalOcean App Platform

Introduction

Containerizing monorepo applications with Docker and deploying them on DigitalOcean App Platform can significantly streamline your development workflow. This approach offers enhanced service isolation, scalability, and efficient deployment, making it easier to manage microservices. By using Docker Compose, developers can create a consistent local environment that mirrors production, ensuring smoother transitions when scaling and managing services. In this article, we’ll guide you through the process of containerizing your monorepo app with Docker, setting up Dockerfiles, and deploying it to DigitalOcean, all while improving CI/CD processes and boosting productivity.

What are the Problems with Monorepo architecture?

Imagine you’re working on a big project, and instead of breaking it into smaller pieces, you decide to put everything in one giant folder. Sounds easy enough, right? Well, that’s what monorepo architecture does—it puts all your services into one codebase. While this might make version control and managing dependencies easier, it can cause some pretty big headaches down the line. For one, putting everything into the same codebase means your services can get tightly tangled. This makes it tough to update one service without it messing up the others, which makes keeping everything running smoothly a real challenge.

Now, think about builds. Each service in the monorepo might need different dependencies and build processes, which can quickly make the build process more complicated than it should be. And when you’re working on your local machine, trying to make everything match the production environment can be a pain. This often leads to your services behaving differently locally than they would in the real world. As if all that wasn’t enough, traditional CI/CD tools aren’t really made for monorepos, so deploying your app feels like you’re trudging through thick mud.

How to resolve these problems?

So, how do we fix these issues? The key is containerization. By containerizing each service, you give each microservice its own little bubble to live in, helping reduce that tangled mess. With Docker and Docker Compose, you can take the complicated parts and break them into smaller, easier pieces. Here’s the game plan:

• Use Docker: Containerize each service on its own so that it has its own environment and doesn’t mess with the others.
• Use Docker Compose: This tool helps you set up and manage multiple containers on your local machine, letting the services communicate without stepping all over each other.
• Deploy to Caasify Cloud Platform: Once you’ve containerized everything, you can deploy each service to the cloud where they can be managed and scaled individually.
• Define Configurations: You’ll need to configure things properly, with shared configurations and environment-specific ones, so the services run smoothly across all environments.

How a Microservices Application Works?

Imagine a microservices application like a team of friends working on a project. Each friend has a specific task, but they all need to work together to finish the job. When someone sends a request, the cloud platform steps in as the traffic controller, directing the request to the right person (or service). Each service is responsible for one task, but they all connect to the same central database. The beauty of microservices is that each one can scale up or down on its own, depending on the demand. And since all services log their actions to a shared logging system, you can monitor everything in one place and keep an eye on how your application is doing.

What are the Benefits of This Architecture?

Now, let’s dive into the real perks of using a microservices architecture, especially when you add Docker into the mix. The benefits are pretty amazing:

• Isolation: Each service lives in its own container with its own resources, which makes sure one service doesn’t mess with another. Plus, you can scale, update, or swap out a service without taking down the whole app.
• Faster CI/CD: With this setup, you only need to redeploy the services that changed. This makes your CI/CD process way faster, cutting down on downtime and speeding up development.
• Developer Productivity: With Docker Compose, developers can work in consistent environments, which means the “it works on my machine” problem is gone. Plus, it makes bringing new team members on board much easier.
• Portability: Containers let your application move smoothly from development to staging to production. No more bugs or configuration headaches tied to different environments.
• Environment Parity: Every service runs the same way, no matter where it is. This consistency ensures that the deployment process is predictable, so you won’t be caught off guard with unexpected issues.
• Scalability: You can scale each service on its own, meaning you use resources more efficiently and save money. If one service is getting hammered, you can scale it up without touching the others.
• Technology Diversity: Each service can use its own tech stack—different languages, frameworks, and dependencies. You can choose the best tool for each job without it messing with other services.
• Fault Tolerance: If one service crashes, it won’t take down the whole app. The isolation helps keep everything stable, even when part of the system goes down.
• Team Autonomy: Teams can work on different services at the same time without stepping on each other’s toes. Everything runs in parallel, which means faster feature delivery.
• Resource Optimization: Containers give each service just the resources it needs, which avoids overloading any one service and boosts overall performance.

Step 1 – How to Structure Your Monorepo?

Let’s say you’re building a house. Instead of cramming everything into one big room, you organize it into separate rooms. That’s exactly what you want to do with your monorepo. You’ll start by creating a services/ directory, where each microservice gets its own little section. This keeps everything isolated and easier to manage. Use these commands to set things up:

$ mkdir -p services/auth-api

$ mkdir -p services/frontend

$ mkdir -p services/log-message-processor

$ mkdir -p services/todos-api

$ mkdir -p services/users-api

$ mkdir -p services/zipkin

This structure makes it easy to add, update, and maintain your services as you go along.

Step 2 – How to Add a Dockerfile to Each Service?

Now it’s time to add a Dockerfile to each of your services. Think of the Dockerfile as a recipe—it tells Docker exactly how to cook up an image for each service. Each microservice in your monorepo will need its own Dockerfile, which defines the steps for building a Docker image for that service. Here’s where you’ll put them:

• microservice-app-example/auth-api/Dockerfile
• microservice-app-example/frontend/Dockerfile
• microservice-app-example/log-message-processor/Dockerfile
• microservice-app-example/todos-api/Dockerfile
• microservice-app-example/users-api/Dockerfile
• microservice-app-example/zipkin/Dockerfile

These Dockerfiles are like blueprints, making it easy to deploy and scale your services consistently across different environments.

Step 3 – How to Create a docker-compose.yml for Local Development?

Once your Dockerfiles are ready, you’ll need to define how all the services talk to each other in a local environment. This is where the docker-compose.yml file comes in. It lets you define and run multiple containers at once. Here’s a sneak peek of what’s inside the docker-compose.yml file:

• Frontend Service: Built from the Dockerfile in the ./frontend directory, it exposes port 8080 and depends on several services, including zipkin, auth-api, todos-api, and users-api.
• Auth-API Service: Built from the ./auth-api directory, it runs on port 8081 and relies on the zipkin and users-api services.
• Todos-API Service: Built from the ./todos-api directory, it listens on port 8082 and is connected to zipkin and redis-queue.
• Users-API Service: Built from the ./users-api directory, it runs on port 8083 and depends on zipkin.
• Log-Message-Processor Service: Built from the ./log-message-processor directory, it depends on zipkin and redis-queue.
• Zipkin Service: This service uses the openzipkin/zipkin image and exposes port 9411.
• Redis-Queue Service: This service uses the redis image to handle queues.

The docker-compose.yml file makes sure everything starts up in the right order and with the right dependencies, which makes testing and running the app locally a breeze.

Step 4 – Test Locally

Once everything is set up, it’s time to test your services locally. Run this command to bring everything to life:

$ docker-compose up –build

Once your services are up and running, check out these URLs to see if everything is working:

• Frontend Service: http://frontend – This is where users will interact with the app.
• Zipkin Service: http://zipkin:9411 – This service helps you monitor your app’s performance and latency.

These links will help you make sure everything is running smoothly and communicating like it should.

Step 5 – How to Push to Git Repository?

Once you’ve tested everything locally, it’s time to push your code to a Git repository. Here’s how:

$ git init

$ git remote add origin https://github.com/zasghar26/microservice-app-example

$ git add .

$ git commit -m “Initial containerized monorepo”

$ git push origin main

Push your monorepo to GitHub, GitLab, or any other platform you prefer.

Step 6 – How to Deploy to Caasify Cloud Platform?

To deploy your containerized monorepo, follow these steps:

• Go to Caasify Cloud Platform and create a new application.
• Link your GitHub or GitLab repository to the platform.
• Add each microservice as a “Web Service” and make sure the services are set up with the right Docker image and environment variables.
• Deploy your services and keep an eye on them as they’re built and deployed by the platform.

Caasify’s platform will ensure that everything runs smoothly, making monitoring easy with real-time performance, logs, and resource usage.

What is Docker?

Conclusion

In conclusion, containerizing a monorepo application with Docker and deploying it to DigitalOcean App Platform offers a streamlined approach to service isolation, scalability, and efficient deployment. By using Docker Compose, developers can set up a consistent local environment, ensuring that microservices work seamlessly both in development and production. This approach simplifies the management of complex applications, improving the CI/CD process and boosting developer productivity. Looking ahead, as cloud platforms evolve, the integration of containerization and scalable deployment tools like DigitalOcean App Platform will continue to enhance the way applications are developed, deployed, and scaled, keeping pace with growing demands in software development and DevOps practices.

Master Docker Installation and Management on Ubuntu 20.04