15 Prompts for CI/CD: GitHub Actions, GitLab CI, and ArgoCD

Create a GitHub Actions workflow for a Node.js application. It should trigger on push to main and on pull requests. Use Ubuntu runner, install dependencies with npm ci, run tests with npm test, and cache node_modules for faster builds.

name: Node.js CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Use Node.js
      uses: actions/setup-node@v4
      with:
        node-version: '20'
    - name: Cache node_modules
      uses: actions/cache@v3
      with:
        path: node_modules
        key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
    - run: npm ci
    - run: npm test

Write a GitHub Actions workflow for deploying a Docker container to staging (on push to develop) and production (on push to main). Use environment secrets for database URLs and API keys. Include a manual approval gate for production.

name: Deploy to Staging and Production

on:
  push:
    branches: [ develop, main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment:
      name: ${{ github.ref_name == 'main' && 'production' || 'staging' }}
    steps:
    - uses: actions/checkout@v4
    - name: Build Docker image
      run: docker build -t myapp:${{ github.sha }} .
    - name: Deploy
      run: |
        echo "Deploying to ${{ github.ref_name == 'main' && 'production' || 'staging' }}"
        # Use secrets: ${{ secrets.DATABASE_URL }}

Generate a GitHub Actions workflow that uses Dependabot to check for npm and Docker dependency updates weekly. Include labels and assignees for the PRs.

version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    labels:
      - "dependencies"
    assignees:
      - "dev-team"
  - package-ecosystem: "docker"
    directory: "/"
    schedule:
      interval: "weekly"

Create a GitHub Actions workflow that runs CodeQL analysis on every push to main and on pull requests. Initialize CodeQL, perform analysis, and upload results. Use JavaScript analysis.

name: CodeQL

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: github/codeql-action/init@v3
      with:
        languages: javascript
    - uses: github/codeql-action/analyze@v3

Write a GitHub Actions composite action that sends a Slack message using a webhook URL. The action should accept a message parameter and the webhook URL as an input.

name: Slack Notification
inputs:
  webhook_url:
    required: true
  message:
    required: true
runs:
  using: composite
  steps:
  - run: |
      curl -X POST -H 'Content-type: application/json' \
        --data '{"text":"${{ inputs.message }}"}' \
        ${{ inputs.webhook_url }}
    shell: bash

Create a .gitlab-ci.yml for a Python application. Use a Python 3.11 image, install dependencies from requirements.txt, run tests with pytest, and cache pip packages. Trigger on push to main.

image: python:3.11

stages:
  - test

cache:
  paths:
    - .pip-cache/

before_script:
  - pip install --cache-dir .pip-cache -r requirements.txt

test:
  stage: test
  script:
    - pytest
  only:
    - main

Generate a GitLab CI pipeline with stages: build (compile code), test (run unit and integration tests), and deploy (deploy to staging using Docker). Use artifacts to pass built binaries between stages.

image: docker:latest

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - docker build -t myapp:$CI_COMMIT_SHA .
    - mkdir -p artifacts
    - echo $CI_COMMIT_SHA > artifacts/version.txt
  artifacts:
    paths:
      - artifacts/

test:
  stage: test
  script:
    - docker run myapp:$CI_COMMIT_SHA npm test

deploy_staging:
  stage: deploy
  script:
    - docker push myapp:$CI_COMMIT_SHA
    - echo "Deploying to staging"
  only:
    - develop

Create a GitLab CI pipeline that runs lint, unit tests, and integration tests in parallel on every push. Use different Docker images for each job to optimize speed.

image: node:20

stages:
  - quality

lint:
  stage: quality
  script:
    - npm ci
    - npm run lint

unit_tests:
  stage: quality
  script:
    - npm ci
    - npm run test:unit

integration_tests:
  stage: quality
  script:
    - npm ci
    - npm run test:integration

Write a GitLab CI job that deploys to staging or production based on the branch name. Use environment scopes to select appropriate variables (e.g., STAGING_URL vs PRODUCTION_URL). Include a manual trigger for production.

deploy:
  stage: deploy
  script:
    - echo "Deploying to $ENVIRONMENT"
  environment:
    name: $CI_ENVIRONMENT_NAME
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
      when: manual
      variables:
        ENVIRONMENT: production
    - if: $CI_COMMIT_BRANCH == "develop"
      variables:
        ENVIRONMENT: staging

Generate a GitLab CI job that deploys a Docker image to a Kubernetes cluster. Use the kubectl image, set up kubeconfig from a CI variable, and apply a deployment.yaml file.

deploy_k8s:
  stage: deploy
  image: bitnami/kubectl:latest
  script:
    - kubectl set image deployment/myapp myapp=myapp:$CI_COMMIT_SHA
  only:
    - main

Write an ArgoCD Application YAML that watches a GitHub repository for changes and syncs manifests to a namespace called 'production'. Use automatic sync with prune.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: myapp
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myorg/myapp.git
    targetRevision: HEAD
    path: kubernetes
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Create two ArgoCD Application resources: one for PostgreSQL (sync wave 0) and one for the app (sync wave 1). The app should only sync after the database is healthy.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: postgres
  annotations:
    argocd.argoproj.io/sync-wave: "0"
spec:
  ...
---
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: myapp
  annotations:
    argocd.argoproj.io/sync-wave: "1"
spec:
  ...

Write an Argo Rollout resource that performs a blue-green update. It should have a preview service for the new version and switch traffic after successful health checks.

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: myapp-rollout
spec:
  replicas: 5
  strategy:
    blueGreen:
      activeService: myapp-active
      previewService: myapp-preview
      autoPromotionEnabled: false
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest

Provide the ArgoCD settings and GitHub webhook configuration to enable automatic sync. Include the webhook secret and the necessary RBAC permissions.

# argocd-cm.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-cm
  namespace: argocd
data:
  repositories: |
    - url: https://github.com/myorg/myapp.git
      type: git
      passwordSecret:
        name: webhook-secret

Create two ArgoCD Application resources targeting different clusters (e.g., us-east and eu-west). Use the same source repo but different destination clusters.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: myapp-us
spec:
  source:
    repoURL: https://github.com/myorg/myapp.git
    path: kubernetes
  destination:
    server: https://us-east-cluster.example.com
    namespace: production
---
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: myapp-eu
spec:
  source:
    repoURL: https://github.com/myorg/myapp.git
    path: kubernetes
  destination:
    server: https://eu-west-cluster.example.com
    namespace: production