Top 10 DevOps Containers in 2023

If you want to learn more about DevOps and building an effective DevOps stack, several containerized solutions are commonly found in production DevOps stacks. I have been working on a deployment in my home lab of DevOps containers that allows me to use infrastructure as code for really cool projects. Let’s consider the top 10 DevOps containers that serve as individual container building blocks for modern DevOps, what these are, and how they are used. Keep in mind this list is simply my thoughts here. First, though, let’s better understand what DevOps is exactly.

What is DevOps?

DevOps is a term that has come about in the past few years that combines development and operations processes. It is a process that automates and integrates software development and IT operations teams. It helps to drastically shorten the development cycle when delivering features, fixes, and updates and allows these to be released more frequently.

Collaboration

The essence of DevOps lies in collaboration. DevOps teams work closely with development and infrastructure teams (these teams may be the same in some organizations). This collaboration results in more efficient and reliable work processes, leading to quicker development and deployment of software.

Why containers are important

Containers are one of the central technologies on which DevOps is built. Containers encapsulate an application and its dependencies, configuration files, etc, into a single executable package, enabling consistency across multiple environments, from a developer’s laptop to a test environment and finally to production.

It makes sure applications run the same regardless of where they are deployed. Rather than being complete operating system images such as installed in a virtual machine, they are application images.

Containers are much quicker and smaller to deploy than monolithic virtual machines. VMs are not as CI/CD pipeline-friendly as containers due to the footprint of VMs vs containers.

Operating System Interaction

Containerized applications run on an operating system, often within virtual machines. The operating system kernel allows multiple containers to share the same OS while running isolated processes.

This supports the deployment of multiple containers on the same machine while containers isolate software from its environment to ensure it works across different environments.

What about Kubernetes?

This post will focus more on Docker containers. However, Kubernetes is the de facto standard in managing and orchestrating containerized applications in a DevOps environment. Kubernetes helps solve many challenges when running multiple containers at scale in the enterprise.

A container orchestrator organizes containers into pods, each running an application that bolsters continuous delivery and integration (CI/CD) processes.

It has features like automatic load balancing, self-healing mechanisms, and rollbacks, allowing DevOps teams to manage and monitor their applications more effectively while utilizing fewer resources. This integration with containers and its automated workflow makes Kubernetes a great tool in the DevOps stack.

The top DevOps containers list

Now, onto the containers! Let’s consider the following:

1. Gitlab

2. Jenkins

3. Harbor

4. Hashicorp Vault

5. ArgoCD

6. Sonarqube

7. Prometheus

8. Grafana

9. Traefik

10. Nginx Proxy Manage

1. GitLab: Collaborative Development Hub

GitLab provides a code repository with many capabilities. It’s also a complete platform for container DevOps, used for deploying containers and collaboration among DevOps teams. I prefer to use Gitlab in my home lab environment and production environments I have worked with as it is extremely intuitive and easy to get up to speed on quickly.

Features

• Integrated CI/CD for swift container deployment

• Provides essential collaboration tools for DevOps teams

• Kubernetes integration supports smooth container orchestration

Download Gitlab here: The DevSecOps Platform | GitLab.

Docker compose code:

gitlab:
    image: gitlab/gitlab-ee:latest
    hostname: 'gitlab.mydomain.com'
    restart: always
    volumes:
      - '~/homelabservices/gitlab/data:/var/opt/gitlab'
      - '~/homelabservices/gitlab/config:/etc/gitlab'
      - '~/homelabservices/gitlab/logs:/var/log/gitlab'

    container_name: gitlab

2. Jenkins: Continuous Integration Powerhouse

Jenkins is an extremely trusted CI/CD solution among DevOps containers, specializing in continuous integration and building containers. It sports a wealth of plugins and integrations that extend its functionality and is used by many organizations worldwide. It is also a favorite for many in the home lab.

Features

• Automated builds and tests for containerized applications

• Facilitates continuous integration in a container environment

• Supports multiple containers with an extensive plugin ecosystem

Download Jenkins here: Jenkins

Docker compose code:

version: '3.8'
  services:
    jenkins:
      image: jenkins/jenkins:lts
      privileged: true
      user: root
      ports:
       - 8080:8080
       - 50000:50000
    container_name: jenkins
    volumes:
      - /home/jenkins_compose/jenkins_configuration:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

3. Harbor: Secure Container Registry

Harbor is a secure container registry vital for managing and securing container images. While you can definitely use Docker Hub where you get a 1 free private repository and then multiple public repos, you can self-host the harbor registry in a Docker container, Linux installation, or in Kubernetes. It allows you to keep your code local.

Features

• Implements role-based access control for container images

• Policy-based image replication

• Scans container images for vulnerabilities

Download Harbor Registry here: Harbor docs | Download the Harbor Installer (goharbor.io)

Docker compose code:

curl -LO https://raw.githubusercontent.com/bitnami/containers/main/bitnami/harbor-portal/docker-compose.yml
curl -L https://github.com/bitnami/containers/archive/main.tar.gz | tar xz --strip=2 containers-main/bitnami/harbor-portal && cp -RL harbor-portal/config . && rm -rf harbor-portal
docker-compose up

4. Hashicorp Vault: Secrets Guardian

Hashicorp Vault is a pivotal DevOps container for secrets management within a container environment. It is a great way to store secrets called in your DevOps code so passwords, tokens, and other sensitive information doesn’t have to be hard coded in your pipelines, config files, manifests, etc.

Features

• Generates dynamic secrets for containers

• Encrypts data for containers in transit and at rest

• Provides temporary access to secrets

Download the Docker Hub image here: hashicorp/vault – Docker Image | Docker Hub

Docker compose code:

version: '3.6'
services:

  vault:
    image: vault:latest
    container_name: vault
    restart: on-failure:10
    ports:
      - "8201:8201"
    environment:
      VAULT_ADDR: 'https://0.0.0.0:8201'
    cap_add:
      - IPC_LOCK
    volumes:
      - vault-volume:/data
    healthcheck:
      retries: 5
    command: ./workflow-vault.sh
    networks:
      - sk_cloud

5. ArgoCD: Kubernetes Deployment Maestro

ArgoCD, a deployment maestro, ensures applications in Kubernetes environments are continuously and consistently deployed across multiple environments.

Features

• Declarative deployments ensure consistency

• Synchronization mechanisms maintain application states

• Visualization tools monitor container clusters

Download ArgoCD here: Argo CD | Argo (argoproj.github.io).

Docker compose code:

version: '2'

services:
  argo-cd:
    image: docker.io/bitnami/argo-cd:2

6. SonarQube: Code Quality Monitor

SonarQube ensures high code quality within containers, identifying and resolving bugs and vulnerabilities in application code deployed in containers.

Features

• Continuous code quality checks

• Automated code reviews

• Supports integration with various CI/CD pipelines

Download Sonarqube here: sonarqube – Official Image | Docker Hub

Docker compose code:

version: "3"
services:
  sonarqube:
    image: sonarqube:community
    hostname: sonarqube
    container_name: sonarqube
    depends_on:
      - db
    environment:
      SONAR_JDBC_URL: jdbc:postgresql://db:5432/sonar
      SONAR_JDBC_USERNAME: sonar
      SONAR_JDBC_PASSWORD: sonar
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
      - sonarqube_logs:/opt/sonarqube/logs
    ports:
      - "9000:9000"
  db:
    image: postgres:13
    hostname: postgresql
    container_name: postgresql
    environment:
      POSTGRES_USER: sonar
      POSTGRES_PASSWORD: sonar
      POSTGRES_DB: sonar
    volumes:
      - postgresql:/var/lib/postgresql
      - postgresql_data:/var/lib/postgresql/data

volumes:
  sonarqube_data:
  sonarqube_extensions:
  sonarqube_logs:
  postgresql:
  postgresql_data:

7. Prometheus: Containers’ Watchguard

Prometheus is a system monitoring tool invaluable for observing multiple containers, ensuring their performance and status are visible and under control.

Features

• Multi-dimensional data modeling

• Nodes independently monitor all containers

• Efficient alerting systems are in place

Download Prometheus here: prom’s Profile | Docker Hub.

Docker compose:

version: '3.8'

volumes:
  prometheus_data: {}
  grafana_data: {}

services:
  prometheus:
    image: prom/prometheus
    restart: always
    volumes:
      - ./prometheus:/etc/prometheus/
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
    ports:
      - 9090:9090

8. Grafana: Data Visualization Expert

Grafana aids in the visualization and analytics of data within containers, supporting diverse data sources and visualization plugins. You can use Grafana for graphing and creating beautiful dashboards for just about anything.

Features

• Customizable dashboards for different containers

• Diverse panel plugins for varied data visualization

• Alerting features for identifying issues proactively

Download the Grafana image: grafana/grafana – Docker Image | Docker Hub.

Docker compose code:

version: "3.8"
services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    ports:
     - '3000:3000'

9. Traefik: Traffic Router

Traefik efficiently balances load across multiple containers, providing automatic service discovery and middleware for modifying requests and responses. It can also handle SSL certificates for your containers and you can use it to automate your Let’s Encrypt certs and renewals.

Features

• Automatic service discovery in container environments

• Middleware supports dynamic modifications of requests and responses

• Clear and intuitive dashboard for monitoring

Download the official Traefik image: traefik – Official Image | Docker Hub.

Docker compose code:

version: '3.3'

services:
  traefik2:
    image: traefik:latest
    restart: always
    command:
      - "--log.level=DEBUG"
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=true"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entryPoint.scheme=https"
    ports:
      - 80:80
      - 443:443
    networks:
      - traefik
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    container_name: traefik

10. Nginx Proxy Manager: Proxy Master

Nginx Proxy Manager simplifies managing proxy hosts within containers, facilitating easy management of HTTP and HTTPS protocols. It can also handle Let’s Encrypt certificates and manage your certificate renewals.

Features

• Streamlined proxy management in containers

• Supports both HTTP and HTTPS protocols

• Provides SSL support for secure connections

Download the official Nginx Proxy Manager Docker image: jc21/nginx-proxy-manager – Docker Image | Docker Hub.

Docker compose code:

version: '3.8'
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: always
    networks:
      - nginxproxy
    ports:
      # These ports are in format <host-port>:<container-port>
      - '80:80' # Public HTTP Port
      - '443:443' # Public HTTPS Port
      - '81:81' # Admin Web Port
      # Add any other Stream port you want to expose
      # - '21:21' # FTP
    environment:
      # Mysql/Maria connection parameters:
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "npm"
      DB_MYSQL_PASSWORD: "npm"
      DB_MYSQL_NAME: "npm"
      # Uncomment this if IPv6 is not enabled on your host
      # DISABLE_IPV6: 'true'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    depends_on:
      - db

  db:
    image: 'jc21/mariadb-aria:latest'
    restart: always
    networks:
      - nginxproxy
    environment:
      MYSQL_ROOT_PASSWORD: 'npm'
      MYSQL_DATABASE: 'npm'
      MYSQL_USER: 'npm'
      MYSQL_PASSWORD: 'npm'
    volumes:
      - ./mysql:/var/lib/mysql

Frequently Asked Questions

How does containerization benefit the software development process?

Containers bundle applications into images, including their dependencies into a single executable package, providing consistency across multiple environments. This approach simplifies application development, deployment, and scaling, making it easier for teams to manage and deploy containers in various stages of the development cycle.

What security considerations are important in DevOps?

Security in DevOps is often referred to as DevSecOps. It involves implementing security practices right from the initial stages of the development cycle. This approach helps identify and mitigate security concerns early, ensuring the deployed containers are secure and the compute environment is protected from potential threats.

What role does the operating system play with containers?

Operating systems are fundamental to container deployment as containers run on them, often within virtual machines, acting as container hosts. The operating system kernel allows multiple containers to run isolated processes while sharing the same OS. This setup supports deploying various containers on the same machine, facilitating efficient use of hardware resources and ensuring applications run uniformly across different environments.

Why is container orchestration important?

Container orchestration is important for managing the lifecycles of multiple containers. It automates the deployment, scaling, and operations of application containers across clusters of hosts. With container orchestration, organizations can efficiently use containerized applications, manage and scale applications as needed, and ensure high availability of services.

Does DevOps depend on specific hardware platforms?

No, DevOps practices can be applied across different hardware platforms. Containers allow applications to run on any computing environment that supports a container runtime. With this capability, DevOps teams can deploy and run applications on multiple hardware platforms, from a developer’s laptop to cloud-based infrastructure.

How do containers support the CI/CD pipeline?

Containers support CI/CD pipelines by providing a consistent and replicable environment for building, testing, and deploying applications. They encapsulate the application and its dependencies, which means that the application can be moved seamlessly through the CI/CD pipeline without worrying about inconsistencies between different stages of the development cycle. They are also much smaller than virtual machines, making them much more CI/CD-friendly.

Wrapping up

The world of DevOps is built upon containerized technologies. Several excellent DevOps containers provide features and functionality essential to the DevOps stack. DevOps engineers can use these containerized solutions together to have efficient CI/CD pipelines, streamlined code, and much more aggressive development lifecycles.