While GitHub itself is highly reliable, maintaining your own backups provides additional protection against accidental deletions, corrupted commits, or organizational changes. GitHub Actions offers several advantages for implementing backup strategies:

• Seamless Automation: Schedule backups to run at specific intervals without requiring manual intervention, ensuring consistent protection of your codebase.
• Version Control Integration: Track your backup history alongside your code changes, maintaining a complete historical record of your repository’s evolution.
• Customizable Workflows: Tailor backup processes to your specific requirements, including selecting which files to include, where to store backups, and how to handle large repositories.
• Storage Flexibility: Send your backups to various destinations including other GitHub repositories, cloud storage providers like AWS S3 or Azure Blob Storage, or even self-hosted servers.
• Cost Efficiency: Implement robust backup solutions without dedicated infrastructure or third-party services, particularly for public repositories with unlimited Action minutes.

GitHub Actions workflows are defined in YAML files stored in the .github/workflows directory of your repository. Follow these steps to create a basic backup workflow:

mkdir -p .github/workflows

name: Repository Backup

on:
  schedule:
    - cron: '0 0 * * *'  # Run daily at midnight UTC
  workflow_dispatch:     # Allow manual triggering

jobs:
  backup:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Fetch all history and tags
          token: ${{ secrets.PAT }}  # Use Personal Access Token

      - name: Set up Git
        run: |
          git config --global user.name 'github-actions'
          git config --global user.email 'github-actions@github.com'

      - name: Create timestamped backup branch
        id: create_branch
        run: |
          TIMESTAMP=$(date +"%Y-%m-%d-%H-%M")
          BRANCH_NAME="backup-$TIMESTAMP"
          git checkout -b $BRANCH_NAME
          echo "BRANCH_NAME=$BRANCH_NAME" >> $GITHUB_ENV

      - name: Push to backup repository
        run: |
          git remote add backup https://${{ secrets.PAT }}@github.com/username/backup-repo.git
          git push backup ${{ env.BRANCH_NAME }} --force

Database Backups with GitHub Actions

For projects that include databases, you can extend your backup workflow to include database dumps:

name: Database Backup

on:
  schedule:
    - cron: "0 */12 * * *" # Runs every 12 hours
  workflow_dispatch:

jobs:
  backup-db:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2

      - name: Set up PostgreSQL client
        run: |
          sudo apt-get update
          sudo apt-get install -y postgresql-client

      - name: Create backup directory
        run: mkdir -p database_backups

      - name: Backup PostgreSQL database
        run: |
          PGPASSWORD=${{ secrets.DB_PASSWORD }} pg_dump \
            -h ${{ secrets.DB_HOST }} \
            -U ${{ secrets.DB_USER }} \
            -d ${{ secrets.DB_NAME }} \
            -F c > database_backups/backup_$(date +%Y%m%d_%H%M%S).dump

      - name: Upload database backup as artifact
        uses: actions/upload-artifact@v4
        with:
          name: database-backup-${{ github.run_id }}
          path: database_backups/
          retention-days: 30

Integrating with Cloud Storage

For long-term storage, consider pushing backups to cloud storage like AWS S3:

- name: Configure AWS credentials
  uses: aws-actions/configure-aws-credentials@v2
  with:
    aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
    aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
    aws-region: us-east-1

- name: Upload backup to S3
  run: |
    zip -r repository-backup-$(date +%Y%m%d_%H%M%S).zip .
    aws s3 cp repository-backup-*.zip s3://my-github-backups/

Backup Retention Policy Implementation

Add steps to manage old backups by implementing a retention policy:

- name: Clean up old backups
  run: |
    # List backups older than 30 days
    OLD_BACKUPS=$(aws s3 ls s3://my-github-backups/ --recursive | awk '{print $4}' | grep -E 'repository-backup-[0-9]{8}_[0-9]{6}\.zip' | sort | head -n -30)
    
    # Delete old backups
    for backup in $OLD_BACKUPS; do
      echo "Deleting old backup: $backup"
      aws s3 rm s3://my-github-backups/$backup
    done

Reddit Stash is an excellent example of GitHub Actions being used for automated data backups. This Python project demonstrates how to create regular backups of Reddit user data including saved posts, comments, and upvoted content.

Implementation Highlights:

• Uses GitHub Actions to run on a scheduled basis (daily, weekly, or monthly)
• Authenticates with the Reddit API to fetch user data
• Stores backups in multiple formats (JSON, CSV, HTML)
• Offers flexible storage options including Dropbox integration
• Includes notification options for backup success or failure

name: Reddit Backup

on:
  schedule:
    - cron: '0 2 * * 0'  # Run weekly on Sundays at 2 AM
  workflow_dispatch:

jobs:
  backup:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
        
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.10'
          
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
          
      - name: Run backup script
        env:
          REDDIT_CLIENT_ID: ${{ secrets.REDDIT_CLIENT_ID }}
          REDDIT_CLIENT_SECRET: ${{ secrets.REDDIT_CLIENT_SECRET }}
          REDDIT_USERNAME: ${{ secrets.REDDIT_USERNAME }}
          REDDIT_PASSWORD: ${{ secrets.REDDIT_PASSWORD }}
          DROPBOX_API_TOKEN: ${{ secrets.DROPBOX_API_TOKEN }}
        run: python reddit_stash.py --all --format json,html --upload-dropbox

Key Takeaways

• GitHub Actions provide a powerful, integrated platform for automating repository backups
• Implementation requires minimal setup with YAML workflow files and appropriate secrets
• Advanced configurations can include database backups and cloud storage integration
• Security best practices include using minimal-permission tokens and secure storage
• Regular testing ensures your backup strategy works when you need it most
• Real-world examples like Reddit Stash demonstrate the versatility of GitHub Actions for data preservation