In this final task, we’ll create a Docker Compose configuration that uses the images we published to GitHub Container Registry in the previous task. This configuration will allow for easy deployment of your entire application.
Create a new directory outside of your project source code. This directory is to simulate a deployment environment where you’ll run your application using Docker Compose.
mkdir posts-app-deployment
cd posts-app-deploymentCreate a file named docker-compose.yml in the posts-app-deployment directory with the following content:
version: '3.8'
services:
api:
image: ghcr.io/cs280su24/cw-24-posts-devop-solution-api:latest
volumes:
- api-data:/app/data
environment:
- DB_FILE=/app/data/sqlite.db
- PORT=3000
ports:
- "3000:3000"
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3000"]
interval: 10s
timeout: 10s
retries: 3
web:
image: ghcr.io/cs280su24/cw-24-posts-devop-solution-web:latest
ports:
- "8080:80"
depends_on:
api:
condition: service_healthy
volumes:
api-data:Replace image values with your own image URLs from GitHub Container Registry.
Let’s break down the key components of this Docker Compose file:
version: Specifies the Docker Compose file format version.
services: Defines the two services of our application: api and web.
api service:
image: Specifies the Docker image to use, pulled from GitHub Container Registry.volumes: Mounts a volume for persistent data storage.environment: Sets environment variables for the API service.ports: Maps port 3000 of the container to port 3000 on the host.healthcheck: Defines a health check to ensure the API is running before starting the web service.web service:
image: Specifies the Docker image for the web application.ports: Maps port 80 of the container to port 8080 on the host.depends_on: Ensures the web service starts only after the API service is healthy.volumes: Defines a named volume api-data for persistent storage.
This configuration sets up the API and web services, ensuring the API is healthy before starting the web service.
To run the application using this Docker Compose file:
Ensure you’re in the posts-app-deployment directory.
Run the following command:
docker-compose up -dThis command will pull the images from GitHub Container Registry (if not already present locally) and start the services.
Access the web application at http://localhost:8080 and the API at http://localhost:3000.
The beauty of this setup is that it can be easily deployed to various platforms. The deployment process will depend on your target environment. However, a general approach involves the following steps:
docker-compose.yml file to the VM.docker-compose up -d to start the application.This process can be automated using Continuous Deployment (CD) pipelines, where changes to your repository trigger the deployment process.
Moreover, instead of using VMs, you can deploy to container orchestration platforms like Kubernetes or Platform as a Service (PaaS) providers that support Docker Compose files directly. This allows you to scale your application easily and manage it efficiently. However, these platforms have a steeper learning curve compared to VM-based deployments.
There are many cloud providers and deployment options available. They all have their unique setup, deployment processes, and pricing model. Choose one that best fits your requirements and budget. The three major cloud providers are AWS, Google Cloud, and Microsoft Azure. Each provides services for setting up VMs or directly deploying containers.
Congratulations! You’ve successfully containerized your application, set up automated builds, and created a deployment-ready Docker Compose configuration. This setup provides a flexible foundation for deploying your application to various environments.
As you continue to develop your application, remember to update your Docker images and the Docker Compose file as needed. Always test your changes locally before deploying to production environments.
This tutorial has covered the basics of containerization and deployment. As you grow more comfortable with these concepts, explore advanced topics such as container orchestration, secret management, and monitoring to further enhance your deployment process.
Happy coding and deploying!