CI/CD Setup

CI/CD Setup for MirthSync

Automate your Mirth Connect or Open Integration Engine deployments with continuous integration and continuous deployment (CI/CD) pipelines. This guide covers complete setup for popular CI/CD platforms with real-world examples.

Why CI/CD for Healthcare Integration?

Automated testing and deployment reduces human error, ensures consistency across environments, and provides audit trails required for healthcare compliance.

Benefits of CI/CD

• Automated Testing - Validate channels before deployment
• Consistent Deployments - Same process every time
• Fast Rollbacks - Quick revert if issues arise
• Audit Trail - Complete deployment history
• Reduced Downtime - Automated processes are faster and more reliable
• Team Confidence - Deployments become routine, not stressful

CI/CD Pipeline Overview

---

CI/CD Platform Setup

GitHub Actions

GitHub Actions Complete Setup

GitHub Actions is tightly integrated with GitHub repositories and offers generous free tier for open source and private repos.

MirthSync is a Java Application

MirthSync is distributed as a Java JAR file, not an npm package. All CI/CD examples below use Java to run MirthSync. Requires Java 8 or higher.

Basic Deployment Workflow

Create .github/workflows/deploy-production.yml:

name: Deploy to Production

on:
  push:
    branches: [main]
  workflow_dispatch: # Manual trigger

env:
  MIRTHSYNC_VERSION: "3.5.0"

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Java
        uses: actions/setup-java@v3
        with:
          distribution: "temurin"
          java-version: "11"

      - name: Download MirthSync
        run: |
          curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v${MIRTHSYNC_VERSION}/mirthsync-${MIRTHSYNC_VERSION}.zip
          unzip mirthsync.zip
          chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh

      - name: Deploy to Production
        run: ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s ${{ secrets.MIRTH_SERVER }} -u ${{ secrets.MIRTH_USERNAME }} -t . --deploy-all push
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.MIRTHSYNC_PASSWORD }}

Multi-Environment Workflow

name: Deploy to Multiple Environments

on:
  push:
    branches:
      - develop # Auto-deploy dev
      - staging # Auto-deploy staging
      - main # Auto-deploy production
  pull_request:
    branches: [main, staging]

env:
  MIRTHSYNC_VERSION: "3.5.0"

jobs:
  # Download MirthSync once and cache it
  setup:
    runs-on: ubuntu-latest
    steps:
      - name: Download MirthSync
        run: |
          curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v${MIRTHSYNC_VERSION}/mirthsync-${MIRTHSYNC_VERSION}.zip
          unzip mirthsync.zip
      - name: Upload MirthSync artifact
        uses: actions/upload-artifact@v3
        with:
          name: mirthsync
          path: mirthsync-${{ env.MIRTHSYNC_VERSION }}

  # Test deployment on PRs (dry run)
  test-deploy:
    needs: setup
    if: github.event_name == 'pull_request'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          distribution: "temurin"
          java-version: "11"
      - uses: actions/download-artifact@v3
        with:
          name: mirthsync
          path: mirthsync
      - run: chmod +x mirthsync/mirthsync.sh
      - name: Test deployment to dev
        run: ./mirthsync/mirthsync.sh -s ${{ secrets.DEV_MIRTH_SERVER }} -u ${{ secrets.DEV_MIRTH_USERNAME }} -t . push
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.DEV_MIRTHSYNC_PASSWORD }}

  # Deploy to dev
  deploy-dev:
    needs: setup
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    environment: development
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          distribution: "temurin"
          java-version: "11"
      - uses: actions/download-artifact@v3
        with:
          name: mirthsync
          path: mirthsync
      - run: chmod +x mirthsync/mirthsync.sh
      - name: Deploy to Dev
        run: ./mirthsync/mirthsync.sh -s ${{ secrets.DEV_MIRTH_SERVER }} -u ${{ secrets.DEV_MIRTH_USERNAME }} -t . --deploy-all push
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.DEV_MIRTHSYNC_PASSWORD }}

  # Deploy to staging
  deploy-staging:
    needs: setup
    if: github.ref == 'refs/heads/staging'
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          distribution: "temurin"
          java-version: "11"
      - uses: actions/download-artifact@v3
        with:
          name: mirthsync
          path: mirthsync
      - run: chmod +x mirthsync/mirthsync.sh
      - name: Deploy to Staging
        run: ./mirthsync/mirthsync.sh -s ${{ secrets.STAGING_MIRTH_SERVER }} -u ${{ secrets.STAGING_MIRTH_USERNAME }} -t . --deploy-all push
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.STAGING_MIRTHSYNC_PASSWORD }}

  # Deploy to production (with approval)
  deploy-production:
    needs: setup
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment:
      name: production
      url: https://mirth.example.com
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          distribution: "temurin"
          java-version: "11"
      - uses: actions/download-artifact@v3
        with:
          name: mirthsync
          path: mirthsync
      - run: chmod +x mirthsync/mirthsync.sh

      - name: Backup Production
        run: |
          mkdir -p backup
          ./mirthsync/mirthsync.sh -s ${{ secrets.PROD_MIRTH_SERVER }} -u ${{ secrets.PROD_MIRTH_USERNAME }} -t ./backup pull
          tar -czf backup-${{ github.sha }}.tar.gz -C backup .
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.PROD_MIRTHSYNC_PASSWORD }}

      - name: Deploy to Production
        run: ./mirthsync/mirthsync.sh -s ${{ secrets.PROD_MIRTH_SERVER }} -u ${{ secrets.PROD_MIRTH_USERNAME }} -t . --deploy-all push
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.PROD_MIRTHSYNC_PASSWORD }}

      - name: Upload Backup
        uses: actions/upload-artifact@v3
        with:
          name: production-backup
          path: backup-${{ github.sha }}.tar.gz
          retention-days: 30

Setting Up Secrets

1. Go to your GitHub repository
2. Navigate to Settings → Secrets and variables → Actions
3. Click New repository secret
4. Add these secrets:
   • MIRTH_SERVER - Your Mirth Connect API URL (e.g., https://mirth.example.com:8443/api)
   • MIRTH_USERNAME - API username
   • MIRTHSYNC_PASSWORD - API password (note: only MIRTHSYNC_PASSWORD is supported as an environment variable)

For multiple environments, use environment-specific secrets:

• DEV_MIRTH_SERVER, DEV_MIRTH_USERNAME, DEV_MIRTHSYNC_PASSWORD
• STAGING_MIRTH_SERVER, STAGING_MIRTH_USERNAME, STAGING_MIRTHSYNC_PASSWORD
• PROD_MIRTH_SERVER, PROD_MIRTH_USERNAME, PROD_MIRTHSYNC_PASSWORD

Approval Gates

Require manual approval for production:

1. Go to Settings → Environments
2. Create environment: production
3. Enable Required reviewers
4. Add team members who can approve deployments

Tip

Use GitHub Environments to require approvals for production deployments. This adds a human safety check before critical changes.

Jenkins

Jenkins Complete Setup

Jenkins offers powerful automation with plugins for every use case.

Install Required Plugins

1. Go to Manage Jenkins → Manage Plugins
2. Install:
   • Git plugin
   • Pipeline plugin
   • Credentials Binding plugin

Configure Java

1. Manage Jenkins → Global Tool Configuration
2. Add JDK installation:
   • Name: JDK 11
   • Version: 11 or higher

Jenkinsfile for Pipeline

Create Jenkinsfile in your repository:

pipeline {
    agent any

    tools {
        jdk 'JDK 11'
    }

    environment {
        MIRTHSYNC_VERSION = '3.5.0'
    }

    stages {
        stage('Setup') {
            steps {
                sh '''
                    curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v${MIRTHSYNC_VERSION}/mirthsync-${MIRTHSYNC_VERSION}.zip
                    unzip -o mirthsync.zip
                    chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh
                '''
            }
        }

        stage('Deploy to Dev') {
            when {
                branch 'develop'
            }
            environment {
                MIRTH_SERVER = credentials('mirth-dev-server')
                MIRTH_USERNAME = credentials('mirth-dev-username')
                MIRTHSYNC_PASSWORD = credentials('mirth-dev-password')
            }
            steps {
                sh './mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $MIRTH_SERVER -u $MIRTH_USERNAME -t . --deploy-all push'
            }
        }

        stage('Deploy to Staging') {
            when {
                branch 'staging'
            }
            environment {
                MIRTH_SERVER = credentials('mirth-staging-server')
                MIRTH_USERNAME = credentials('mirth-staging-username')
                MIRTHSYNC_PASSWORD = credentials('mirth-staging-password')
            }
            steps {
                sh './mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $MIRTH_SERVER -u $MIRTH_USERNAME -t . --deploy-all push'
            }
        }

        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            environment {
                MIRTH_SERVER = credentials('mirth-prod-server')
                MIRTH_USERNAME = credentials('mirth-prod-username')
                MIRTHSYNC_PASSWORD = credentials('mirth-prod-password')
            }
            steps {
                // Require manual approval
                input message: 'Deploy to production?', ok: 'Deploy'

                // Backup before deployment
                sh 'mkdir -p backup && ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $MIRTH_SERVER -u $MIRTH_USERNAME -t ./backup pull'
                sh 'tar -czf backup-${BUILD_NUMBER}.tar.gz -C backup .'
                archiveArtifacts artifacts: 'backup-*.tar.gz', fingerprint: true

                // Deploy
                sh './mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $MIRTH_SERVER -u $MIRTH_USERNAME -t . --deploy-all push'
            }
        }
    }

    post {
        success {
            echo 'Deployment successful!'
            // Send notification (Slack, email, etc.)
        }
        failure {
            echo 'Deployment failed!'
            // Send alert
        }
    }
}

Setting Up Credentials

1. Manage Jenkins → Manage Credentials
2. Add credentials for each environment:
   • Kind: Secret text
   • ID: mirth-prod-server, mirth-prod-username, mirth-prod-password
   • Secret: Your values

Creating Jenkins Job

1. New Item → Pipeline
2. Configure:
   • Pipeline → Definition: Pipeline script from SCM
   • SCM: Git
   • Repository URL: Your Git repository
   • Script Path: Jenkinsfile
3. Save

GitLab CI

GitLab CI Complete Setup

GitLab CI is built into GitLab and offers excellent integration with GitLab repositories.

Basic Pipeline

Create .gitlab-ci.yml:

image: eclipse-temurin:11-jdk

stages:
  - setup
  - deploy-dev
  - deploy-staging
  - deploy-production

variables:
  MIRTHSYNC_VERSION: "3.5.0"

setup-mirthsync:
  stage: setup
  script:
    - curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v${MIRTHSYNC_VERSION}/mirthsync-${MIRTHSYNC_VERSION}.zip
    - unzip mirthsync.zip
  artifacts:
    paths:
      - mirthsync-${MIRTHSYNC_VERSION}/
    expire_in: 1 hour

# Deploy to development
deploy-dev:
  stage: deploy-dev
  needs: [setup-mirthsync]
  script:
    - chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh
    - ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $DEV_MIRTH_SERVER -u $DEV_MIRTH_USERNAME -t . --deploy-all push
  environment:
    name: development
    url: https://mirth-dev.example.com
  only:
    - develop
  variables:
    MIRTHSYNC_PASSWORD: $DEV_MIRTHSYNC_PASSWORD

# Deploy to staging
deploy-staging:
  stage: deploy-staging
  needs: [setup-mirthsync]
  script:
    - chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh
    - ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $STAGING_MIRTH_SERVER -u $STAGING_MIRTH_USERNAME -t . --deploy-all push
  environment:
    name: staging
    url: https://mirth-staging.example.com
  only:
    - staging
  variables:
    MIRTHSYNC_PASSWORD: $STAGING_MIRTHSYNC_PASSWORD

# Deploy to production (manual approval required)
deploy-production:
  stage: deploy-production
  needs: [setup-mirthsync]
  script:
    - chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh
    - mkdir -p backup && ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $PROD_MIRTH_SERVER -u $PROD_MIRTH_USERNAME -t ./backup pull
    - tar -czf backup-${CI_COMMIT_SHA}.tar.gz -C backup .
    - ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s $PROD_MIRTH_SERVER -u $PROD_MIRTH_USERNAME -t . --deploy-all push
  environment:
    name: production
    url: https://mirth.example.com
  when: manual
  only:
    - main
  variables:
    MIRTHSYNC_PASSWORD: $PROD_MIRTHSYNC_PASSWORD
  artifacts:
    paths:
      - backup-*.tar.gz
    expire_in: 30 days

Setting Up Variables

1. Go to your GitLab project
2. Settings → CI/CD → Variables
3. Add environment variables:
   • DEV_MIRTH_SERVER (Protected: No, Masked: Yes)
   • DEV_MIRTH_USERNAME (Protected: No, Masked: Yes)
   • DEV_MIRTHSYNC_PASSWORD (Protected: No, Masked: Yes)
   • STAGING_MIRTH_SERVER (Protected: No, Masked: Yes)
   • STAGING_MIRTH_USERNAME (Protected: No, Masked: Yes)
   • STAGING_MIRTHSYNC_PASSWORD (Protected: No, Masked: Yes)
   • PROD_MIRTH_SERVER (Protected: Yes, Masked: Yes)
   • PROD_MIRTH_USERNAME (Protected: Yes, Masked: Yes)
   • PROD_MIRTHSYNC_PASSWORD (Protected: Yes, Masked: Yes)

Protected Variables

Mark production variables as “Protected” so they’re only available on protected branches (main/master).

Azure DevOps

Azure DevOps Complete Setup

Azure DevOps pipelines integrate well with Azure infrastructure.

Azure Pipeline YAML

Create azure-pipelines.yml:

trigger:
  branches:
    include:
      - main
      - develop
      - staging

pool:
  vmImage: "ubuntu-latest"

variables:
  javaVersion: "11"
  MIRTHSYNC_VERSION: "3.5.0"

stages:
  - stage: DeployDev
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/develop'))
    jobs:
      - deployment: DeployToDev
        environment: development
        strategy:
          runOnce:
            deploy:
              steps:
                - task: JavaToolInstaller@0
                  inputs:
                    versionSpec: $(javaVersion)
                    jdkArchitectureOption: "x64"
                    jdkSourceOption: "PreInstalled"

                - script: |
                    curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v$(MIRTHSYNC_VERSION)/mirthsync-$(MIRTHSYNC_VERSION).zip
                    unzip mirthsync.zip
                    chmod +x mirthsync-$(MIRTHSYNC_VERSION)/mirthsync.sh
                  displayName: "Download MirthSync"

                - script: ./mirthsync-$(MIRTHSYNC_VERSION)/mirthsync.sh -s $(DEV_MIRTH_SERVER) -u $(DEV_MIRTH_USERNAME) -t . --deploy-all push
                  displayName: "Deploy to Development"
                  env:
                    MIRTHSYNC_PASSWORD: $(DEV_MIRTHSYNC_PASSWORD)

  - stage: DeployProduction
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: DeployToProduction
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - task: JavaToolInstaller@0
                  inputs:
                    versionSpec: $(javaVersion)
                    jdkArchitectureOption: "x64"
                    jdkSourceOption: "PreInstalled"

                - script: |
                    curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v$(MIRTHSYNC_VERSION)/mirthsync-$(MIRTHSYNC_VERSION).zip
                    unzip mirthsync.zip
                    chmod +x mirthsync-$(MIRTHSYNC_VERSION)/mirthsync.sh
                  displayName: "Download MirthSync"

                - script: |
                    mkdir -p backup
                    ./mirthsync-$(MIRTHSYNC_VERSION)/mirthsync.sh -s $(PROD_MIRTH_SERVER) -u $(PROD_MIRTH_USERNAME) -t ./backup pull
                    tar -czf backup-$(Build.BuildNumber).tar.gz -C backup .
                  displayName: "Backup Production"
                  env:
                    MIRTHSYNC_PASSWORD: $(PROD_MIRTHSYNC_PASSWORD)

                - task: PublishBuildArtifacts@1
                  inputs:
                    pathToPublish: "backup-$(Build.BuildNumber).tar.gz"
                    artifactName: "production-backup"

                - script: ./mirthsync-$(MIRTHSYNC_VERSION)/mirthsync.sh -s $(PROD_MIRTH_SERVER) -u $(PROD_MIRTH_USERNAME) -t . --deploy-all push
                  displayName: "Deploy to Production"
                  env:
                    MIRTHSYNC_PASSWORD: $(PROD_MIRTHSYNC_PASSWORD)

Setting Up Variables

1. Go to Pipelines → Library

2. Create variable group: Mirth-Dev

   • Add: DEV_MIRTH_SERVER, DEV_MIRTH_USERNAME, DEV_MIRTHSYNC_PASSWORD

3. Create variable group: Mirth-Production

   • Add: PROD_MIRTH_SERVER, PROD_MIRTH_USERNAME, PROD_MIRTHSYNC_PASSWORD
   • Lock variables (click padlock icon)

4. In your pipeline, link variable groups:

   • Edit pipeline → Variables → Variable groups → Link variable group

---

Advanced CI/CD Patterns

Testing Before Deployment

# GitHub Actions example
test:
  runs-on: ubuntu-latest
  env:
    MIRTHSYNC_VERSION: "3.5.0"
  steps:
    - uses: actions/checkout@v3
    - uses: actions/setup-java@v3
      with:
        distribution: "temurin"
        java-version: "11"
    - name: Download MirthSync
      run: |
        curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v${MIRTHSYNC_VERSION}/mirthsync-${MIRTHSYNC_VERSION}.zip
        unzip mirthsync.zip
        chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh

    # Run custom tests on transformer JavaScript
    - name: Test transformers
      run: npm test

    # Lint JavaScript in transformers
    - name: Lint code
      run: npm run lint

Blue-Green Deployments

# Deploy to "green" environment
./mirthsync.sh -s $GREEN_MIRTH_SERVER -u $MIRTH_USERNAME -t . --deploy-all push

# Run smoke tests on green
./run-smoke-tests.sh $GREEN_MIRTH_SERVER

# If tests pass, switch traffic to green
# (via load balancer configuration)

# Keep blue as rollback option for 24 hours

Canary Deployments

# Deploy to first production server (10%)
./mirthsync.sh -s $PROD_SERVER1 -u $MIRTH_USERNAME -t . --deploy-all push

# Monitor metrics for 1 hour
# If no issues, deploy to remaining servers (90%)
./mirthsync.sh -s $PROD_SERVER2 -u $MIRTH_USERNAME -t . --deploy-all push
./mirthsync.sh -s $PROD_SERVER3 -u $MIRTH_USERNAME -t . --deploy-all push

Scheduled Deployments

GitHub Actions - Deploy at specific time:

on:
  schedule:
    - cron: "0 2 * * 0" # 2 AM every Sunday
  workflow_dispatch: # Also allow manual trigger

Jenkins - Scheduled builds:

pipeline {
    triggers {
        cron('H 2 * * 0')  # 2 AM every Sunday
    }
    // ...
}

---

Rollback Strategies

Automatic Rollback on Failure

# GitHub Actions
- name: Deploy to Production
  id: deploy
  run: ./mirthsync/mirthsync.sh -s ${{ secrets.PROD_MIRTH_SERVER }} -u ${{ secrets.PROD_MIRTH_USERNAME }} -t . --deploy-all push
  env:
    MIRTHSYNC_PASSWORD: ${{ secrets.PROD_MIRTHSYNC_PASSWORD }}
  continue-on-error: true

- name: Smoke Test
  id: test
  run: ./smoke-test.sh
  continue-on-error: true

- name: Rollback on Failure
  if: steps.deploy.outcome == 'failure' || steps.test.outcome == 'failure'
  run: |
    echo "Deployment or tests failed, rolling back..."
    git checkout HEAD~1
    ./mirthsync/mirthsync.sh -s ${{ secrets.PROD_MIRTH_SERVER }} -u ${{ secrets.PROD_MIRTH_USERNAME }} -t . -f --deploy-all push
  env:
    MIRTHSYNC_PASSWORD: ${{ secrets.PROD_MIRTHSYNC_PASSWORD }}

Manual Rollback Workflow

name: Rollback Production

on:
  workflow_dispatch:
    inputs:
      commit:
        description: "Commit SHA to rollback to"
        required: true

env:
  MIRTHSYNC_VERSION: "3.5.0"

jobs:
  rollback:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Checkout target commit
        run: git checkout ${{ github.event.inputs.commit }}

      - uses: actions/setup-java@v3
        with:
          distribution: "temurin"
          java-version: "11"
      - name: Download MirthSync
        run: |
          curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v${MIRTHSYNC_VERSION}/mirthsync-${MIRTHSYNC_VERSION}.zip
          unzip mirthsync.zip
          chmod +x mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh

      - name: Rollback Production
        run: ./mirthsync-${MIRTHSYNC_VERSION}/mirthsync.sh -s ${{ secrets.PROD_MIRTH_SERVER }} -u ${{ secrets.PROD_MIRTH_USERNAME }} -t . -f --deploy-all push
        env:
          MIRTHSYNC_PASSWORD: ${{ secrets.PROD_MIRTHSYNC_PASSWORD }}

---

Monitoring & Notifications

Slack Notifications

GitHub Actions:

- name: Notify Slack on Success
  if: success()
  uses: slackapi/slack-github-action@v1
  with:
    payload: |
      {
        "text": "✅ Production deployment successful",
        "blocks": [
          {
            "type": "section",
            "text": {
              "type": "mrkdwn",
              "text": "Deployed ${{ github.sha }} to production"
            }
          }
        ]
      }
  env:
    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}

- name: Notify Slack on Failure
  if: failure()
  uses: slackapi/slack-github-action@v1
  with:
    payload: |
      {
        "text": "❌ Production deployment failed"
      }
  env:
    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}

Email Notifications

Jenkins:

post {
    success {
        emailext (
            subject: "✅ Deployment Successful: ${env.JOB_NAME}",
            body: "Build ${env.BUILD_NUMBER} deployed successfully",
            to: "team@example.com"
        )
    }
    failure {
        emailext (
            subject: "❌ Deployment Failed: ${env.JOB_NAME}",
            body: "Build ${env.BUILD_NUMBER} failed. Check console output.",
            to: "team@example.com"
        )
    }
}

---

Security Best Practices

Secret Management

1. Never commit secrets to Git

   • Use CI/CD platform’s secret management
   • Rotate secrets regularly
   • Use different credentials per environment

2. Principle of Least Privilege

   • CI/CD user should have minimal required permissions
   • Read-only in dev, write in staging/production
   • Separate credentials per environment

3. Audit Logging

   • Enable audit logs in Mirth Connect
   • Log all CI/CD deployments
   • Review logs regularly

Network Security

# Example: Deploy from specific IP ranges only
# Configure in your CI/CD platform or firewall

# GitHub Actions: Use self-hosted runners in your network
jobs:
  deploy:
    runs-on: [self-hosted, production]

---

Troubleshooting

”mirthsync.sh: command not found” or “java: not found"

# Ensure Java is installed
- uses: actions/setup-java@v3
  with:
    distribution: "temurin"
    java-version: "11"

# Download and make executable
- run: |
    curl -L -o mirthsync.zip https://github.com/SagaHealthcareIT/mirthsync/releases/download/v3.5.0/mirthsync-3.5.0.zip
    unzip mirthsync.zip
    chmod +x mirthsync-3.5.0/mirthsync.sh

"Connection refused to Mirth Connect”

• Verify server URL includes /api path (e.g., https://mirth.example.com:8443/api)
• Check firewall rules allow CI/CD server IP
• Confirm Mirth Connect is running
• Test connection manually first

”Authentication failed”

• Verify credentials are correct
• Check if credentials expired or need rotation
• Ensure CI/CD user has API access enabled in Mirth Connect
• Remember: only MIRTHSYNC_PASSWORD is supported as an environment variable