Setting up continuous integration with GitHub

Ron Powell — Mon, 17 Sep 2018 19:48:00 +0000

This article was originally posted on CircleCI's blog by Stanley Ndagi

Continuous Integration (CI) involves the test automation of feature branches before they are merged to the main Git branch in a project. This ensures that a codebase does not get updated with changes that could break something. Continuous Delivery (CD), on the other hand, builds upon CI by automating releases of these branches and/or the main branch. This allows small incremental updates to reach your users faster, in line with Agile software development philosophy.

In this article, I will take you through setting up CI with GitHub. We will use a Python application to demonstrate our CI pipeline.

Here are the steps we will take:

Create a simple Python application (with Flask)
Create tests for this app
Add the config.yml file
Push to GitHub
Configure CircleCI
Update our README with a badge
Create a PR and see CircleCI in action

Creating a simple Python app

Prerequisites

If you don’t have Python installed, follow the instructions here for your local system. The Python installation comes with pip (The PyPA recommended tool for installing Python packages).

Building the app

For simplicity, in terms of fewest lines of code, we will create a Flask application. Flask is a microframework for Python. For our exercise, little knowledge of the framework is necessary. We’ll use the example found here.

First, create a project directory (folder) and cd into it. Type this into Terminal:

mkdir python_app && cd $_/

Next, open your favorite editor and create a hello.py file. Then, copy the following lines into that file:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

Virtual environments in Python

When working in Python, it is strongly advised that you use a virtual environment. This allows you to install Python packages in an abstracted environment that is not your entire local machine. Some common ways to do this are to use virtualenv or, even better, virtualenvwrapper. We’ll use the module venv that comes as a part of Python3. This is how it’s done:

Create the virtual environment:

python3 -m venv venv

(Note that we can use other names for our virtual environment, like in the next example.)

python3 -m venv Env

Activate this environment:

source venv/bin/activate

(Replace venv if you used another name for the environment)

You will notice (venv) just before the shell prompt telling you that the virtual environment is active. Any Python package that is installed will be installed within this environment. To deactivate this environment simply run:

deactivate

Running the app

Now, let’s create a requirements.txt file in our editor. Add the word Flask to the file and save it.

Flask

Then, within the virtual environment, install the package by running:

pip install -r requirements.txt

The final command to run this application is:

FLASK_APP=hello.py flask run

You can see the application running on your browser at http://localhost:5000/.

Tests

In your editor, create a tests.py file and paste these lines into it:

from hello import app
with app.test_client() as c:
    response = c.get('/')
    assert response.data == b'Hello World!'
    assert response.status_code == 200

Please see these references for more information on tests:

Now, let’s run our test. Open Terminal and run:

python3 tests.py

Nothing should be returned to our Terminal. Why? The reason is that we structured our Flask app so that it does not output to Terminal on a pass. This means that our tests are passing. The resources mentioned above give better examples of Terminal UX (user experience) on tests passing and failing, but this will suffice for our case.

CircleCI config file

Create a .circleci folder and inside of that create a config.yml file. Then, copy these lines into it:

version: 2
jobs:
  build:
    docker:
      - image: circleci/python:3.6
    steps:
      - checkout
      - restore_cache:
          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
      - run:
          command: |
            python3 -m venv venv
            . venv/bin/activate
            pip install -r requirements.txt
      - save_cache:
          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
          paths:
            - "venv"
      - run:
          name: Running tests
          command: |
            . venv/bin/activate
            python3 tests.py
      - store_artifacts:
          path: test-reports/
          destination: python_app

For more information regarding this config file, see: https://circleci.com/docs/2.0/language-python/.

Pushing to GitHub

We should have initialized Git earlier and had atomic commits (the philosophy of committing your code early and often). However, since this tutorial is about integration of CircleCI and GitHub, I intentionally put it on hold until now.

Our current code structure looks like this:

Open your editor and create a .gitignore file in the working directory to state which files and folders that we don’t want to commit to Git. Copy the following lines into that file:

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]

# Virtualenv
venv/*

We are now going to commit our code by running the following commands:

git add .

git commit -m "Initial commit"

Go to https://github.com and create a GitHub account, if you don’t already have one. Then, create a repository.

After creating your new repository, you will get to a page like this one:

We’ll go with the second option, …push an existing repository. Run:

git remote add origin https://github.com/NdagiStanley/python_app.git
git push -u origin master

Configuring CircleCI

Now that the repo is on GitHub, we can finalize the CI by configuring CircleCI.

Head on over to https://circleci.com/. Then click Sign Up at the top right.

Once you are logged in, ensure that your personal GitHub account is active. If you are in several GitHub organizations, one of them might be active. Just click the drop down menu (top left) and select your GitHub username. Then, click Add Projects. The most recent project, ‘python_app’, appears there.

Click Set up Project at the right side of the row that includes our project. On the redirected page, you’ll notice the Next Steps section. Had we not had our own .circleci/config.yml file, we would have started at No. 1. We just need to scroll to No. 5 and click Start building.

Within no time, the build passes. It's successful!

In the top right corner, click the Settings cog. Then click Projects on the left, and finally, python_app.

You will be on a path like this one: circleci.com/gh/<username>/python_app. Mine is https://circleci.com/gh/NdagiStanley/python_app. Click the settings cog next to the repo name: python_app.

It is important that you to become familiar with the settings that you can change for this project. I will touch on what is relevant to us now.

In Advanced Settings, notice that Only build pull requests is turned off. This means that every push to GitHub will run on CircleCI, including PRs.

In Chat Notifications, notice that you can configure your Slack, HipChat, FlowDock, Campfire and IRC to be notified on every build. For Slack, this resource is handy.

In Status Badges, notice the Markdown embed code. We will copy this code to paste into our README.

ReadME - status badge

On our local machine, checkout to another Git branch by running:

git checkout -b add_readme

Open your editor and create a README.md file. Copy and paste the following lines into this file:

README.md
# PYTHON APPLICATION
This Python application repo was created to showcase the integration between GitHub and CircleCI.
[![CircleCI](https://circleci.com/gh/NdagiStanley/python_app.svg?style=svg)](https://circleci.com/gh/NdagiStanley/python_app)

I added a title and a brief description to mine.

Now, run the following commands:

git add .
git commit -m "Add README"
git push -u origin add_readme

If you go to https://github.com//python_app you will notice that we have a new branch: add_readme. We can go ahead and click Compare and pull request.

Opening a pull request

This is how I set up my PR:

Click Create pull request and in no time, this is what we get:

A successful build! Now, click Show all checks. You will see that the check is from CircleCI.

Even the browser’s tab favicon shows a tick for the successful run:

If you click Details, this will redirect you to the build on CircleCI:

Notice that the favicon here also shows that the build is successful:

At the top, click python_app

You are redirected to the builds for this project:

Conclusion

And there you have it! We have integrated GitHub with CircleCI. In summary, we set up a Python application and created tests for it. We then created a CircleCI config file and pushed the codebase to GitHub. Finally, we connected the GitHub repository we created to CircleCI.

If you followed through successfully, you can now set up your own project in GitHub and configure CI builds on CircleCI. The following links point to my references while writing this article.

https://circleci.com/docs/2.0/configuration-reference/#full-example
http://flask.pocoo.org/
https://circleci.com/docs/2.0/configuration-reference/

About Stanley: From a young age, Stanley tinkered with electronics and building things with tech. Now, he’s an engineer at Andela and his work involves data, the web, and IoT. Stemming from his lifelong love of DIY, he’s on a personal journey of invoking the builder within and teaching others along the way. He cares about how technology affects society and seeks collaborations with others who are working to create positive impact.

DEV Community: Ron Powell