Environment Variables in Workflows

Environment Variables in Workflows

In this lesson, we will explore how to use and manage environment variables within GitHub Actions workflows. Environment variables are critical for configuring your workflows dynamically and securely. They allow you to pass data between different steps in your workflow and can be used to store sensitive information, such as API keys or configuration settings.

What are Environment Variables?

Environment variables are key-value pairs that can be used to configure the behavior of applications or scripts. In the context of GitHub Actions, they allow you to customize the execution of your workflows without hardcoding values directly into your scripts. This makes your workflows more flexible and easier to manage.

For example, you might want to use different API endpoints for development and production environments. By using environment variables, you can change the endpoint without modifying your code.

Setting Environment Variables in GitHub Actions

You can define environment variables in several places in your GitHub Actions workflow:

1. Workflow Level: These variables are available to all jobs and steps in the workflow.
2. Job Level: Variables defined at this level are accessible to all steps within the job.
3. Step Level: These variables are only available to the specific step where they are defined.

Workflow Level Example

You can set environment variables at the workflow level using the env keyword:

name: CI

on:
  push:
    branches:
      - main

env:
  NODE_ENV: production
  API_URL: https://api.example.com

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test

In this example, the NODE_ENV and API_URL environment variables are available to all steps within the build job. This means that you can access these variables in any of the steps simply by referencing them as $NODE_ENV and $API_URL.

Job Level Example

You can also define environment variables at the job level. Here’s how it looks:

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      NODE_ENV: development
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Print environment variable
        run: echo "Current environment: $NODE_ENV"

In this case, NODE_ENV is only available within the build job. When you run this, the output will be Current environment: development.

Step Level Example

Finally, you can define environment variables at the step level:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set environment variable
        run: echo "MY_VAR=Hello World" >> $GITHUB_ENV
      - name: Print environment variable
        run: echo "$MY_VAR"

In this example, we set an environment variable MY_VAR using the special $GITHUB_ENV file. This makes MY_VAR available in subsequent steps of the job. The output will be Hello World.

Using Environment Variables in Your Scripts

Once you have defined environment variables, you can use them in your scripts. In shell scripts, you can access the variables using the syntax $VARIABLE_NAME. In JavaScript or Node.js scripts, you can access them using process.env.VARIABLE_NAME.

Example in a Shell Script

Here’s how you can use environment variables in a shell script:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Run a shell script
        run: |
          echo "Deploying to environment: $NODE_ENV"
          curl -X POST $API_URL/deploy

In this example, we are using the environment variables NODE_ENV and API_URL in a shell command to print the environment and make a deployment call.

Best Practices for Using Environment Variables

1. Use Descriptive Names: Choose clear and descriptive names for your environment variables. This makes it easier for others to understand their purpose.
2. Keep Sensitive Data Secure: Avoid exposing sensitive information in your logs. Use GitHub Secrets for sensitive data instead of plain environment variables.
3. Limit Scope: Define environment variables only in the scope where they are needed. This minimizes the risk of accidental misuse.
4. Use Default Values: When possible, provide default values for environment variables to ensure your workflows can run even if certain variables are not defined.

Advanced Examples

Combining Environment Variables with Secrets

You can combine environment variables with GitHub Secrets for added security. Here’s a practical example:

name: CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      NODE_ENV: production
      API_URL: ${{ secrets.API_URL }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Deploy
        run: |
          echo "Deploying to environment: $NODE_ENV"
          curl -X POST $API_URL/deploy

In this example, we are using a secret stored in GitHub to set the API_URL environment variable. This keeps our sensitive data safe while still allowing us to use it in our workflows.

Performance Considerations

Using environment variables can help improve the performance of your workflows by allowing you to reuse values across multiple steps, reducing the need for repeated hardcoded values. However, excessive use of environment variables can lead to complexity and confusion. Always strive for a balance between flexibility and simplicity.

Comparison with Alternative Approaches

While environment variables are a powerful feature in GitHub Actions, there are alternative approaches to manage configurations:

• Configuration Files: You can store configuration settings in YAML or JSON files within your repository. This approach can be more structured but may require additional parsing logic in your workflows.
• Command-Line Arguments: For some workflows, passing parameters directly to scripts via command-line arguments can be simpler than using environment variables.

Common Interview Questions

1. What are environment variables, and why are they used in CI/CD pipelines?
   Environment variables are key-value pairs that configure the behavior of applications or scripts. They are used in CI/CD pipelines to maintain flexibility and security by allowing dynamic configuration without hardcoding values.

2. How do you securely manage sensitive information in GitHub Actions?
   Use GitHub Secrets to store sensitive information securely. Secrets are encrypted and can be referenced in workflows without exposing them in logs.

3. Can you provide an example of how to set and use environment variables in GitHub Actions?
   Yes, environment variables can be set at the workflow, job, or step level using the env keyword. They can be accessed in scripts using $VARIABLE_NAME for shell scripts or process.env.VARIABLE_NAME for Node.js scripts.

Mini Project: Building a Dynamic Deployment Workflow

For this mini-project, you will create a GitHub Actions workflow that deploys your application to different environments based on the branch being pushed.

1. Define environment variables for API_URL and NODE_ENV at the workflow level.
2. Use a conditional statement to set different values for these variables based on the branch name (e.g., development branch uses a different API URL than the main branch).
3. Create steps that print the current environment and make a mock deployment call using curl.

Key Takeaways

• Environment variables are essential for configuring workflows dynamically and securely.
• They can be defined at the workflow, job, or step level, with varying scopes.
• Use environment variables to avoid hardcoding sensitive information and to improve workflow flexibility.
• Always follow best practices for naming, security, and scope management.

In the next lesson, we will delve into Secrets Management in GitHub Actions, where we will learn how to securely store and use sensitive information in our workflows.

• Exercise 1: Create a simple GitHub Actions workflow that sets an environment variable at the workflow level and accesses it in a job step.
• Exercise 2: Modify the previous workflow to include a job-level environment variable and demonstrate its use.
• Exercise 3: Create a workflow that uses a secret to set an environment variable and accesses it in a step.
• Exercise 4: Write a script in your workflow that uses multiple environment variables to construct a URL and make a mock API call.
• Mini Project: Build a GitHub Actions workflow that deploys an application to different environments based on the branch being pushed, using environment variables to manage configurations.

• Environment variables are key-value pairs used to configure workflows dynamically.
• They can be defined at the workflow, job, or step level.
• Environment variables improve flexibility and security in CI/CD pipelines.
• Best practices include using descriptive names and keeping sensitive data secure.
• Combining environment variables with secrets enhances security in workflows.