Skill: GitHub Actions Management

Purpose

Configure and manage GitHub Actions for CI/CD pipelines, automated testing, and deployment workflows.

When to Use

• Setting up CI/CD pipelines
• Configuring automated testing
• Managing deployment workflows
• Monitoring workflow runs
• Troubleshooting failed actions

Tools Used

• gh CLI (GitHub CLI)
• GitHub Actions YAML configuration
• GitHub API

Configuration

{
  "owner": "{{github.owner}}",
  "repo": "{{github.repo}}",
  "defaultBranch": "{{github.defaultBranch}}"
}

---

Managing Workflows with gh CLI

Listing Workflows

# List all workflows
gh workflow list

# View specific workflow
gh workflow view "CI"

# View workflow file
gh workflow view "CI" --yaml

Running Workflows

# Run workflow manually
gh workflow run "CI"

# Run with inputs
gh workflow run "deploy" -f environment=staging

# Run on specific branch
gh workflow run "CI" --ref feature-branch

Viewing Runs

# List recent runs
gh run list

# List runs for specific workflow
gh run list --workflow "CI"

# List failed runs
gh run list --status failure

# View specific run
gh run view <run-id>

# View run logs
gh run view <run-id> --log

# Watch run in progress
gh run watch <run-id>

Managing Runs

# Re-run failed jobs
gh run rerun <run-id>

# Re-run all jobs
gh run rerun <run-id> --failed

# Cancel run
gh run cancel <run-id>

# Download artifacts
gh run download <run-id>

---

Workflow Configuration

Basic CI Workflow

# .github/workflows/ci.yml
name: CI

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

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Test
        run: npm test

      - name: Build
        run: npm run build

CI with Matrix Testing

name: CI Matrix

on: [push, pull_request]

jobs:
  test:
    runs-on: ${{ matrix.os }}

    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node: [18, 20, 22]
        exclude:
          - os: windows-latest
            node: 18

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js ${{ matrix.node }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}

      - run: npm ci
      - run: npm test

PR Checks Workflow

name: PR Checks

on:
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm run lint

  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm test -- --coverage
      - name: Upload coverage
        uses: codecov/codecov-action@v3

  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm run build

Deployment Workflow

name: Deploy

on:
  push:
    branches: [main]
  workflow_dispatch:
    inputs:
      environment:
        description: 'Environment to deploy to'
        required: true
        default: 'staging'
        type: choice
        options:
          - staging
          - production

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: ${{ github.event.inputs.environment || 'staging' }}

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install and Build
        run: |
          npm ci
          npm run build

      - name: Deploy to ${{ github.event.inputs.environment || 'staging' }}
        run: |
          echo "Deploying to ${{ github.event.inputs.environment || 'staging' }}"
          # Add deployment commands here
        env:
          DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}

---

Common Workflow Patterns

Caching Dependencies

- name: Cache node modules
  uses: actions/cache@v3
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-node-

Using Services (Databases)

jobs:
  test:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:14
        env:
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
          POSTGRES_DB: test
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test
        env:
          DATABASE_URL: postgres://test:test@localhost:5432/test

Conditional Jobs

jobs:
  deploy-staging:
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying to staging"

  deploy-production:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying to production"

Job Dependencies

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - run: echo "Building"

  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - run: echo "Testing"

  deploy:
    needs: [build, test]
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying"

---

Secrets Management

Using Secrets

steps:
  - name: Deploy
    env:
      API_KEY: ${{ secrets.API_KEY }}
      DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
    run: ./deploy.sh

Managing Secrets with gh CLI

# List secrets
gh secret list

# Set secret
gh secret set API_KEY

# Set secret from file
gh secret set API_KEY < api-key.txt

# Set secret for environment
gh secret set API_KEY --env production

# Delete secret
gh secret delete API_KEY

---

Debugging Workflows

Enable Debug Logging

# In workflow file
env:
  ACTIONS_STEP_DEBUG: true
  ACTIONS_RUNNER_DEBUG: true

Using tmate for SSH Access

- name: Setup tmate session
  if: ${{ failure() }}
  uses: mxschmitt/action-tmate@v3
  with:
    limit-access-to-actor: true

Common Issues

Issue	Cause	Solution
Permission denied	Missing permissions	Add permissions block
Secret not found	Wrong name or scope	Verify secret exists
Cache miss	Key changed	Check cache key pattern
Timeout	Long-running job	Increase timeout or optimize

---

Workflow Templates

Release Workflow

name: Release

on:
  release:
    types: [published]

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          registry-url: 'https://registry.npmjs.org'
      - run: npm ci
      - run: npm publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

Scheduled Workflow

name: Scheduled Tasks

on:
  schedule:
    - cron: '0 0 * * *'  # Daily at midnight

jobs:
  cleanup:
    runs-on: ubuntu-latest
    steps:
      - run: echo "Running scheduled cleanup"

---

Jira Integration

Log Workflow Status to Jira

// On workflow failure, create bug
Atlassian:createJiraIssue({
  cloudId: "{{jira.cloudId}}",
  projectKey: "{{jira.bugs.projectKey}}",
  issueTypeName: "Bug",
  summary: "CI Pipeline Failure: {{workflowName}}",
  description: `## CI Pipeline Failure

**Workflow:** {{workflowName}}
**Run:** [#{{runId}}]({{runUrl}})
**Branch:** {{branch}}
**Commit:** {{commitSha}}

### Error
\`\`\`
{{errorOutput}}
\`\`\`

### Failed Jobs
{{#each failedJobs}}
- {{jobName}}: {{error}}
{{/each}}`,
  labels: ["ci-failure", "automated"]
})

---

Used By Agents

Agent	GitHub Actions Use
DevOps Engineer	Primary - creates and maintains workflows
Senior Developer	Reviews workflow changes
QA Engineer	Monitors test workflow results
Project Manager	Tracks deployment status

Best Practices

1. Use caching - Speed up workflows significantly
2. Parallelize jobs - Independent jobs run concurrently
3. Fail fast - Stop early on critical failures
4. Keep secrets secure - Never log or expose secrets
5. Use environments - Separate staging/production
6. Monitor and alert - Set up notifications for failures