DEV Community: Qasim Aziz

Setting Up DevOps Monitoring and Automation with Jenkins, Prometheus, Grafana, and Docker

Qasim Aziz — Thu, 25 Jul 2024 09:49:25 +0000

In this guide, we'll explore how to create a DevOps monitoring and automation system using Jenkins for CI/CD, Prometheus for metrics collection, Grafana for data visualization, and Docker for containerization.

Installing Docker
First, ensure Docker is installed on your system. Follow the installation instructions provided on the Docker website for your specific operating system.

Setting Up Jenkins
To run Jenkins in a Docker container, execute the following command:

docker run -u 0 --privileged --name jenkins -it -d -p 8080:8080 -p 50000:50000 \
-v /var/run/docker.sock:/var/run/docker.sock \
-v $(which docker):/usr/bin/docker \
-v /home/jenkins_home:/var/jenkins_home \
jenkins/jenkins:latest

Access and Configure Jenkins
Open your browser and navigate to http://localhost:8080.
Provide the initial admin password, which can be found by running docker logs .
Install the suggested plugins during the initial setup.
From the Jenkins dashboard, create a new item and choose "Pipeline".

Install Required Plugins
Navigate to "Manage Jenkins" > "Manage Plugins" and install the following plugins:

Docker Plugin
Docker Pipeline Plugin
Prometheus Metrics Plugin
Restart Jenkins if prompted.

Setting Up Prometheus and Grafana
Create a Docker Network

docker network create monitoring

Run Prometheus
Create a prometheus.yml configuration file with the following content:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'jenkins'
    static_configs:
      - targets: ['jenkins:8080']
      metrics_path: '/prometheus'

  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

Run Prometheus with this configuration:

docker run -d --name=prometheus --network=monitoring -p 9090:9090 \
-v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

Run Node Exporter

docker run -d --name=node-exporter --network=monitoring --restart=unless-stopped prom/node-exporter

Run Grafana

docker run -d --name=grafana --network=monitoring -p 3000:3000 grafana/grafana

Configuring Grafana
Access Grafana
Open your browser and go to http://localhost:3000. Log in with the default credentials (username: admin, password: admin).

Add Prometheus as a Data Source
Navigate to "Data Sources" on the left sidebar, click "Add data source," and select "Prometheus".
Enter http://prometheus:9090 as the Prometheus server URL.
Click "Save & Test".
Create a Dashboard
Select "Dashboards" from the left sidebar to create a new dashboard.
Import a dashboard using an ID or URL (e.g., ID: 11159).
Add a query to visualize Jenkins job duration:

default_jenkins_builds_last_build_duration_milliseconds

Automating Application Deployment with Jenkins
Set Up a Jenkins Pipeline
From your Jenkins dashboard, navigate to your pipeline project, go to "Configure," and add the following script under "Pipeline Script":

pipeline {
    agent any

    environment {
        DB_HOST = 'your-db-host'
        DB_USER = 'your-db-user'
        DB_PASS = 'your-db-password'
        DB_NAME = 'your-db-name'
    }

    stages {
        stage('Checkout') {
            steps {
                script {
                    checkout([$class: 'GitSCM', branches: [[name: '*/main']],
                      doGenerateSubmoduleConfigurations: false,
                      extensions: [[$class: 'CleanCheckout']],
                      submoduleCfg: [],
                      userRemoteConfigs: [[url: 'https://github.com/yourusername/your-nodejs-typescript-api-repo.git',
                      credentialsId: 'git-credentials-id']]
                    ])
                }
            }
        }

        stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }

        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }

        stage('Test') {
            steps {
                sh 'npm test'
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    sh 'docker build -t your-dockerhub-username/your-nodejs-typescript-api:latest .'
                }
            }
        }

        stage('Push Docker Image') {
            steps {
                script {
                    withCredentials([usernamePassword(credentialsId: 'dockerhub-credentials', usernameVariable: 'DOCKER_USERNAME', passwordVariable: 'DOCKER_PASSWORD')]) {
                        sh 'echo $DOCKER_PASSWORD | docker login -u $DOCKER_USERNAME --password-stdin'
                    }
                    sh 'docker push your-dockerhub-username/your-nodejs-typescript-api:latest'
                }
            }
        }

        stage('Deploy') {
            steps {
                script {
                    sh '''
                    docker run -d -p 3000:3000 \
                        -e NODE_ENV=$NODE_ENV \
                        -e DB_HOST=$DB_HOST \
                        -e DB_USER=$DB_USER \
                        -e DB_PASS=$DB_PASS \
                        -e DB_NAME=$DB_NAME \
                        your-dockerhub-username/your-nodejs-typescript-api:latest
                    '''
                }
            }
        }

        stage('Monitor') {
            steps {
                script {
                    // Additional monitoring setup can be added here
                }
            }
        }
    }

    post {
        success {
            echo 'Build succeeded!'
        }
        failure {
            echo 'Build failed!'
        }
    }
}

Adding Credentials
Add credentials for GitHub and Docker in Jenkins:

Navigate to "Manage Jenkins" > "Credentials".
Select "Global" and add your credentials for GitHub and Docker. Note the ID, as it will be referenced in the pipeline script.
By following these steps, you can set up a comprehensive DevOps monitoring and automation tool using Jenkins, Prometheus, Grafana, and Docker.
Build Application
Build your application and view the metrics on the Grafana dashboard 😃.

Streamlining CI/CD Pipelines with Hasura GraphQL Engine

Qasim Aziz — Tue, 20 Feb 2024 12:42:31 +0000

In the dynamic landscape of API management, the perennial debate surrounding architectural choices - whether it's gRPC, traditional HTTP, or the revolutionary GraphQL - remains ever-present. Drawing from a wealth of experience amassed over years in the tech industry, one conclusion stands out: GraphQL, with its unparalleled performance and precision, emerges as the optimal solution for real-world scenarios.
Unleashing the Power of GraphQL.

What sets GraphQL apart is its innate ability to deliver exactly what is needed, precisely when it's needed. Unlike traditional HTTP endpoints, where retrieving data often entails fetching entire objects and sifting through unwanted information, GraphQL empowers developers to fetch only the necessary details, significantly streamlining the process. Imagine a scenario where you're dealing with massive datasets but require only specific fields - GraphQL's fine-grained control ensures you retrieve precisely what's required, enhancing efficiency and performance manifold.

Embracing Hasura: The Game-Changer in GraphQL Implementation
Enter Hasura - a transformative force in the realm of GraphQL. With its comprehensive feature set and intuitive interface, Hasura simplifies schema creation and management, making it the go-to choice for developers seeking simplicity without compromising on power. The Hasura CLI facilitates seamless migration management, empowering teams to deploy with confidence and ease.

Automating CI/CD Pipelines: A Custom Solution with GitLab, Docker, and Kubernetes

Now, let's dive into the heart of the matter: automating CI/CD pipelines for Hasura. I'll guide you through a custom solution tailored to seamlessly integrate with your preferred pipeline tools, leveraging the robust capabilities of GitLab, Docker, and Kubernetes to ensure high availability and scalability.

Setting the Stage
Firstly, let's establish a dedicated repository to manage Hasura metadata and migrations. Initiate your project with the Hasura CLI and utilize the console to generate database schemas and migrations effortlessly. Ensure you have the necessary prerequisites in place:

Prerequisites:

Hasura CLI
Docker installed
Docker Compose
Git repository
Git Helm chart repository

https://git.opshive.io/myproject/hasura.git
Run hasura init to create the project directory, guiding you through the initial setup process and allowing you to configure basic settings locally.
Crafting the Environment
Next, let's configure the Dockerfile at the root of your project to facilitate container creation and automated migration processing:

FROM hasura/graphql-engine:v2.27.0.cli-migrations-v3

RUN mkdir /app
WORKDIR /appd

COPY ./myproject /app

Additionally, prepare a Docker Compose file to orchestrate multiple containers and the database, ensuring seamless integration:

version: "3.6"
services:
  graphql-engine:
    build: 
      context: ./
      dockerfile: Dockerfile 
    # image: hasura/graphql-engine:v2.27.0.cli-migrations-v3
    ports:
      - "8080:8080"
    restart: always
    environment:
      HASURA_GRAPHQL_MIGRATIONS_DIR: /app/migrations
      HASURA_GRAPHQL_METADATA_DIR: /app/metadata
      ## postgres database to store Hasura metadata
      ## this env var can be used to add the above postgres database to Hasura as a data source. this can be removed/updated based on your needs
      HASURA_GRAPHQL_DATABASE_URL: postgres://postgres:postgres@postgres:5432/myproject
      ## enable the console served by server
      HASURA_GRAPHQL_ENABLE_CONSOLE: "true" # set to "false" to disable console
      ## enable debugging mode. It is recommended to disable this in production
      HASURA_GRAPHQL_DEV_MODE: "true"
      HASURA_GRAPHQL_ENABLED_LOG_TYPES: startup, http-log, webhook-log, websocket-log, query-log
      ## uncomment next line to run console offline (i.e load console assets from server instead of CDN)
      # HASURA_GRAPHQL_CONSOLE_ASSETS_DIR: /srv/console-assets
      ## uncomment next line to set an admin secret
      HASURA_GRAPHQL_ADMIN_SECRET: myadminsecretkey
  postgres:
    image: postgres:14.1-alpine
    container_name: pg_db
    restart: always
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    ports:
      - '5432:5432'
    volumes:
      - postgresql:/var/lib/postgresql/data
  pgadmin:
    container_name: pgadmin_container-new
    image: dpage/pgadmin4
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL:-pgadmin4@pgadmin.org}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD:-admin}
      PGADMIN_CONFIG_SERVER_MODE: 'False'
    volumes:
       - pgadmin:/var/lib/pgadmin
      #  - /home/opshive/workspace/qasim/storage/projects/fabmedic/hasura/pg_backups:/tmp
    ports:
      - "${PGADMIN_PORT:-5050}:80"
volumes:
  postgresql:
    driver: local
  pgadmin:

This setup enables you to launch all containers and access the Hasura console for schema creation and management locally:

docker-compose up -d
cd myproject 
hasura console --endpoint=localhost:8080 --admin-secret=myadminsecretkey

Automating Deployment: A GitLab CI/CD Pipeline
With the foundation laid, it's time to automate deployment to your development server. Create a .gitlab-ci.yml file at the root of your project with the following content

image: docker:latest
stages:
  - docker-build-dev
  - patch-dev

docker-build-dev:
  stage: docker-build-dev

  services: 
    - name: docker:dind    
  before_script:
    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD" "docker.io"
  script:
    - docker build . -t "$DEV_IMAGE_NAME":"$CI_COMMIT_SHA" 
    - docker push "$DEV_IMAGE_NAME":"$CI_COMMIT_SHA"

  tags:
    - my-runner
  only:
    - dev

patch-dev:
  stage: patch-dev
  script:
    - |
      apk add git
      git clone -b main $HELM_REPO
      cd helm-charts/myproject-hasura
      git config credential.helper store
      rm -f dev-values.yaml   
      cat <<EOF >> dev-values.yaml
      replicaCount: 1

      image:
        repository: $DEV_IMAGE_NAME
        pullPolicy: IfNotPresent
        # Overrides the image tag whose default is the chart appVersion.
        tag: "$CI_COMMIT_SHA"

      imagePullSecrets:
      - name: mypullsecret
      nameOverride: ""
      fullnameOverride: "hasura-dev"

      serviceAccount:
        # Specifies whether a service account should be created
        create: true
        # Annotations to add to the service account
        annotations: {}
        # The name of the service account to use.
        # If not set and create is true, a name is generated using the fullname template
        name: ""

      podAnnotations: {}

      podSecurityContext: {}
        # fsGroup: 2000

      securityContext: {}
        # capabilities:
        #   drop:
        #   - ALL
        # readOnlyRootFilesystem: true
        # runAsNonRoot: true
        # runAsUser: 1000

      service:
        type: ClusterIP
        port: 8080

      ingress:
        enabled: true
        className: "nginx"
        annotations:
          kubernetes.io/ingress.class: nginx
          kubernetes.io/tls-acme: "true"
          nginx.ingress.kubernetes.io/proxy-body-size: 100m
          cert-manager.io/cluster-issuer: letsencrypt-mydomain-issuer-dns
        hosts:
          - host: dev-hasura.mydomain.io
            paths:
              - path: /
                pathType: ImplementationSpecific
        tls:
          - secretName: domain-hasura-tls
            hosts:
            - dev-hasura.mydomain.com
        # livenessProbe:
        #   httpGet:
        #     path: /
        #     port: http
        # readinessProbe:
        #   httpGet:
        #     path: /
        #     port: http
      resources: 
        # We usually recommend not to specify default resources and to leave this as a conscious
        # choice for the user. This also increases chances charts run on environments with little
        # resources, such as Minikube. If you do want to specify resources, uncomment the following
        # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
        limits:
          cpu: 1000m
          memory: 800Mi
        requests:
          cpu: 250m
          memory: 128Mi

      autoscaling:
        enabled: false
        minReplicas: 1
        maxReplicas: 3
        targetCPUUtilizationPercentage: 80
        # targetMemoryUtilizationPercentage: 80

      nodeSelector: {}

      tolerations: []

      affinity: {}
      # configmaps
      HASURA_GRAPHQL_DATABASE_URL: "postgresql://user:securepassword@postgresql-server:5432/devmyproject"
      HASURA_GRAPHQL_ENABLE_CONSOLE: "true"
      HASURA_GRAPHQL_DEV_MODE: "false"
      HASURA_GRAPHQL_ADMIN_SECRET: "ASD78F5ASD95FGAS8765GSD6F9S7F69ASD78"
      HASURA_GRAPHQL_ENABLE_ALLOWLIST: "false"
      HASURA_GRAPHQL_ENABLED_LOG_TYPES: "startup,http-log,query-log,websocket-log,webhook-log"
      HASURA_GRAPHQL_UNAUTHORIZED_ROLE: "anonymous"

      HASURA_GRAPHQL_CORS_DOMAIN: "*"

      EOF
      git config --global user.email "bot@mycompany.com"
      git config --global user.name "bot"
      git add .
      git commit -m "$CI_COMMIT_SHA"
      git push origin main
  tags:
    - my-runner
  only:
    - dev

By following these meticulously crafted steps, you'll seamlessly integrate Hasura GraphQL Engine into your CI/CD workflows, fostering efficiency, reliability, and scalability throughout the development lifecycle.

This comprehensive guide empowers developers to harness the full potential of GraphQL with Hasura while streamlining CI/CD processes for unparalleled efficiency and agility.