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.
Top comments (0)