Beginner's Guide to Git & GitLab Runner: What They Are and How to Use Them for Automated Deployments

Introduction: Why Git and Automation Matter

In today's fast-paced development world, effective version control and automated deployments aren't just nice-to-haves—they're essential tools in every developer's arsenal. Whether you're a seasoned DevOps engineer or just starting your journey, understanding Git and GitLab Runner can transform your workflow and boost your team's productivity.

At DevOps Horizon, we've seen firsthand how proper implementation of these tools can slash deployment times and eliminate many common errors. In this guide, we'll walk you through everything you need to know—from the basics of Git to setting up automated deployments with GitLab Runner.

What is Git? A Simple Explanation

Git is a distributed version control system that tracks changes in your code over time. Unlike older version control systems, Git allows multiple developers to work on the same project simultaneously without stepping on each other's toes.

Key Git Concepts for Beginners:

• Repository (Repo): A storage location for your project, containing all files and the history of changes made to those files.
• Commit: A snapshot of your project at a specific point in time.
• Branch: A parallel version of your repository that allows you to work on different features without affecting the main codebase.
• Merge: The process of combining changes from different branches.
• Pull Request/Merge Request: A way to propose changes to a repository that other developers can review.

Basic Git Commands You Should Know:

# Initialize a new Git repository
git init

# Clone an existing repository
git clone https://repository-url.git

# Check the status of your repository
git status

# Add changes to staging area
git add filename

# Commit your changes
git commit -m "Your commit message"

# Push changes to remote repository
git push origin branch-name

# Pull changes from remote repository
git pull origin branch-name

Understanding GitLab: More Than Just Git Hosting

GitLab is a complete DevOps platform that provides Git repository management, issue tracking, CI/CD pipelines, and more. While GitHub might be more widely known, GitLab offers integrated CI/CD capabilities that make it particularly powerful for automated workflows.

GitLab CI/CD Overview

Continuous Integration (CI) and Continuous Deployment (CD) are practices that automate the building, testing, and deployment of applications. GitLab implements CI/CD through:

• A .gitlab-ci.yml file in your repository that defines your pipeline
• Runners that execute the jobs defined in your pipeline
• Integration with your development workflow

What is GitLab Runner?

GitLab Runner is an application that works with GitLab CI/CD to run the jobs in your pipeline. It's the workhorse that executes the scripts you define in your .gitlab-ci.yml file, allowing you to automate everything from testing to deployment.

Types of GitLab Runners:

1. Shared Runners: Available to all projects in a GitLab instance
2. Group Runners: Available to all projects in a specific group
3. Project Runners: Dedicated to specific projects
4. Specific Runners: Can be assigned to multiple projects with specific tags

Each type has its own use cases, but for most beginners, project runners provide a good balance of simplicity and control.

Setting Up GitLab Runner: A Step-by-Step Guide

Let's walk through the process of installing and configuring GitLab Runner for your projects.

Step 1: Install GitLab Runner

The installation process varies by operating system:

For Linux (Debian/Ubuntu):

# Add GitLab's official repository
curl -L "https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh" | sudo bash

# Install the runner
sudo apt-get install gitlab-runner

For macOS:

# Using Homebrew
brew install gitlab-runner
brew services start gitlab-runner

For Windows:
Download the binary from GitLab's website and run the installation wizard.

Step 2: Register Your Runner

After installation, you need to register your runner with your GitLab instance:

1. Go to your GitLab project
2. Navigate to Settings > CI/CD > Runners
3. Note the registration token
4. Run the registration command:

sudo gitlab-runner register

You'll be prompted for:

• The GitLab instance URL
• The registration token
• A description for the runner
• Tags (optional, but useful for specific job targeting)
• The executor (choose shell for beginners)

Step 3: Configure the Runner

After registration, your runner's configuration is stored in /etc/gitlab-runner/config.toml (Linux/macOS) or C:\GitLab-Runner\config.toml (Windows). You can edit this file to fine-tune your runner's behavior:

concurrent = 1
check_interval = 0

[[runners]]
name = "My First Runner"
url = "https://gitlab.com/"
token = "YOUR_TOKEN"
executor = "shell"
[runners.custom_build_dir]
[runners.cache]
  [runners.cache.s3]
  [runners.cache.gcs]

Creating a CI/CD Pipeline with GitLab Runner

Now that your runner is set up, it's time to create a pipeline that will automate your deployments.

Step 1: Create a .gitlab-ci.yml File

In the root of your repository, create a file named .gitlab-ci.yml:

stages:
- build
- test
- deploy

build_job:
stage: build
script:
  - echo "Building the application..."
  - npm install  # or any build command for your project

test_job:
stage: test
script:
  - echo "Running tests..."
  - npm test  # or any test command for your project

deploy_job:
stage: deploy
script:
  - echo "Deploying application..."
  - rsync -avz --delete ./dist/ user@server:/path/to/deployment/
only:
  - main  # Only deploy when changes are pushed to the main branch

Step 2: Push Your Changes

Once you've created the .gitlab-ci.yml file, commit and push it to your repository:

git add .gitlab-ci.yml
git commit -m "Add GitLab CI/CD pipeline configuration"
git push origin main

Step 3: Monitor Your Pipeline

After pushing, go to your GitLab project and navigate to CI/CD > Pipelines to see your pipeline in action. You'll be able to track the progress of each job and troubleshoot any issues that arise.

Advanced GitLab Runner Configuration for Automated Deployments

As you become more comfortable with GitLab CI/CD, you can explore more advanced configurations:

Environment Variables

Store sensitive information like API keys or deployment credentials as protected variables:

1. Go to Settings > CI/CD > Variables
2. Add your variables with appropriate protection
3. Use them in your .gitlab-ci.yml like this:

deploy_job:
script:
  - sshpass -p $SERVER_PASSWORD scp -r ./dist/* user@$SERVER_ADDRESS:/path/to/deployment/
variables:
  SERVER_ADDRESS: "example.com"
only:
  - main

Using Docker Executors

For more consistent builds, consider using Docker as your executor:

build_job:
image: node:16
script:
  - npm install
  - npm run build

Caching Dependencies

Speed up your builds by caching dependencies between jobs:

cache:
paths:
  - node_modules/

build_job:
script:
  - npm install
  - npm run build

Pros and Cons of Using GitLab Runner for Automated Deployments

Pros:

1. Integrated Solution: Everything works within the GitLab ecosystem
2. Flexibility: Works with various environments and deployment targets
3. Customization: Highly configurable to meet specific needs
4. Free Tier Available: You can get started without upfront costs
5. Self-Hosted Option: For teams with strict security requirements

Cons:

1. Learning Curve: Initial setup can be challenging for beginners
2. Resource Intensive: Runners require system resources to operate
3. Maintenance Overhead: Self-hosted runners need regular updates and maintenance
4. Limited Free Minutes: Cloud-hosted runners have limits on free tier
5. Debugging Challenges: Pipeline issues can sometimes be difficult to troubleshoot

Best Practices for GitLab CI/CD

To get the most out of GitLab Runner and CI/CD:

1. Keep Pipelines Fast: Optimize your jobs to run quickly
2. Use Caching Wisely: Cache dependencies but not large artifacts
3. Implement Proper Testing: Ensure your tests are thorough and reliable
4. Secure Your Secrets: Never hardcode sensitive information
5. Document Your Pipeline: Make sure your team understands how the pipeline works
6. Use Tags Effectively: Organize runners with meaningful tags
7. Monitor Runner Performance: Keep an eye on resource usage

Conclusion: Taking Your First Steps with GitLab Runner

Getting started with Git and GitLab Runner might seem daunting at first, but the benefits of automated deployments far outweigh the initial setup costs. By following this guide, you've taken your first steps toward a more efficient development workflow.

Remember that automation is a journey, not a destination. Start small, perhaps with just a build and test pipeline, then gradually add more sophisticated deployment steps as you become more comfortable with the tools.

If you're looking to deepen your DevOps skills further, check out our other tutorials on Kubernetes, Terraform, and AWS at DevOps Horizon.

Happy automating!