In Part 2, we will dive into continuous integration and continuous deployment (CI/CD) by connecting your repository to Jenkins. You’ll learn how to:

• Create a Jenkinsfile to define the CI/CD pipeline.
• Write a Dockerfile to containerize your Flask application.
• Set up Jenkins to automatically build a Docker image and push it to your repository with every commit to the master branch.

By the end of this tutorial, you’ll have a fully automated pipeline that streamlines your development process — making every push to the master branch trigger a deployment without any manual intervention.

Let’s get started

First, you will need to create the following Dockerfile in your repository to create a Docker image from my application. In this case, my “Dockerfile” would look like this:

FROM python:3.11-alpine

# Create a working directory
WORKDIR /flaskapp

# Copy requirements
COPY requirements.txt .

# Install dependencies
RUN pip3 install --no-cache-dir -r requirements.txt

# Copy the application
COPY . .

# Expose the port
EXPOSE 5000

# Command to start the app
CMD ["python3", "main.py"]

Next, I will create a “Jenkinsfile”:

node {
    def app
    
    stage('Clone repository') {
        checkout scm
    }

    stage('Build image') {
        container('docker') {
                app = docker.build("myproduct.gt.amojisys.com/root/myrepo:1.${env.BUILD_NUMBER}", "--network host .")
        }
    }
    
    stage('Push image') {
        container('docker') {
            docker.withRegistry('https://myproduct.gt.amojisys.com', 'gitea_access_token') {
                app.push("1.${env.BUILD_NUMBER}")
            }
        }
    }
}

In this script, I utilize a Docker container (DinD), which is provided by a Jenkins agent, to build an image and push it to the repository. I am also utilizing Jenkins job’s build number for automatic versioning.

You can get access to the Docker daemon by utilizing the “docker” container in your pipeline.

Once you add “Dockerfile” and “Jenkinsfile”, I can push the changes to the repository.

You will need a Jenkins server to be able to put all the pieces together. So, I am going to create a Jenkins Cluster service on the Amojisys app.

When Jenkins server is deployed, you will login using “admin” username and the password I initiated when creating the service.

To install the requirements for creating a pipeline and building a Docker image, we will need “Pipeline” and “Docker Pipeline” plugins installed. You can install plugins by navigating to “Manage Jenkins”, “Plugins”, and then “Available plugins”.

Next, you will create a global credential for accessing your Gitea repository by going to “Manage Jenkins”, “Credentials”, “System”, and “Global credentials”. In my pipeline, I use this credential as “gitea_access_token” so I will set the same name for the input.

Now, you will go back to the dashboard, create a new job, and choose “Pipeline”. In the configuration, you will enable the “Poll SCM” option so this job can check my repository on a schedule, and if there are any changes, it will get triggered. I will choose every 5 minutes as my Schedule “H/5 * * * *”.

In the “Definition” section, I choose “Pipeline script from SCM”. I will select “Git” as “SCM” and enter my repository’s url. I will select the Credentials that I defined earlier and choose the master branch to push and build images from. You can add more configurations depending on your needs. This will satisfy all I want to do for now, so I will save my pipeline.

Now, I will build the job by clicking on “Build Now” which will assign the agent server to my job to execute my pipeline.

You can track the progress of my pipeline in detail by clicking on the build number and navigating to “Console Output”.

Finally, you can go back to yout Gitea server and check if the image was added to “root” user’s packages.

I can see the Docker image under packages with a tag version of 1.1, which will increment on each run. So, the next time I push to the master branch, there will be a new image there with the version 1.2.

Great job! You have successfully built a complete CI/CD pipeline using Jenkins, Docker, VS Code server, and your Gitea repository. With the Jenkinsfile and Dockerfile in place, your Flask application can now be automatically built, containerized, and deployed as a Docker image every time you push to the master branch.

This powerful automation saves you time, reduces errors, and ensures a smoother development-to-deployment process. By integrating these tools with Amojisys, you have created a workflow that is scalable, efficient, and optimized for collaboration.

As you continue building and refining your applications, your new pipeline will keep everything running smoothly, allowing you to focus on what really matters — creating great software.

Thank you for following along! Stay tuned for more tutorials as we continue to explore ways to enhance your development processes with Amojisys.

In Part 1, I will show you how to:

• Set up a repository on your own Gitea Server for easy version control.
• Deploy a Visual Studio Code Server to clone the repository and begin coding remotely.
• Build a simple Flask application, test it locally, and push the changes back to the repository.

By the end of this part, you’ll have a fully functional Flask app hosted in your own repository, ready to be integrated with automated processes.

In Part 2, I will take it a step further by integrating Jenkins to automatically create Docker images of your application with every push, bringing your workflow full circle.

Let’s dive in and start simplifying your development process with Amojisys!

Before you start, you need to register and create an organization on Amojisys app. You can find the tutorial on this YouTube video or the Documentations page.

Once you are signed in to your organization as an Owner user, you will be able to create services.

First, you will create a Gitea server to maintain my repository.

When the instance is running, you will click on the URL to set up your Gitea server. You can choose whether to host your repository database on your Gitea server or select an external database to store your data to have more control. I will choose SQLite3 which will store the database on the same container as my Gitea server.

You can configure your server as you wish. I will change the following values for a simple set up:

1- Server Domain: “myproduct.gt.amojisys.com”

2 - Gitea Base URL: “https://myproduct.gt.amojisys.com”

3 - Disable self-registration, so no external user can register.

4 - Create an Admin user and password

After a successful installation, you will log in to your account, click on your profile on the top-right corner of the page, and choose settings. You will then switch to the Applications tab to create an Access Token and will store it for future use.

Now, it is time to create a repository for the Flask application!

The next step is to create a VS Code server on Amojisys to develop and test your application.

Once ready, you will open the online VS Code server and enter your password to login.

Within VS Code you will clone your repository by using a terminal and git command.

You will install Python extension. Also, pip for installing packages by running the following commands in terminal

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python3-pip

You will create a “main.py” file that contains my application code and a “requirements.txt” for any dependencies.

My main.py file will contain:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def entry():
    return "Welcome to my application!"

if __name__ == "__main__":
    app.run(host="0.0.0.0")

My requirements.txt will contain:

Flask

Afterwards, you will run the following command to install the dependencies on terminal:

pip3 install -r myrepo/requirements.txt

Now you have everything you need to run the app. you will navigate to Run & Debug on the left navigation menu. Create a launch.json file for Python which should look like this:

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "justMyCode": true
        }
    ]
}

Once you have a Python debugger set up, you can run and test your application on the server.

You can see that the application is running on port 5000 of the following addresses on VS Code server:

127.0.0.1
10.233.109.124

To make sure you can send requests to your application, you can use CURL to send a GET request.

You can see the application running and sending a response. Great!

You need to push your new changes to the repository, but one final step is to configure a name and an email address for your git configuration in the terminal:

git config --global user.name "David Smith"
git config --global user.email "d.smith@test.com"

Finally, you can push your changes to the repo.

Congratulations! You’ve successfully set up a repository on Gitea, deployed a remote Visual Studio Code Server, and built a simple Flask application. By pushing your changes back to the repository, you’ve laid the groundwork for a more efficient and collaborative development workflow.

This is just the beginning. In Part 2, we will take things further by introducing Jenkins into the mix. You will learn how to automate the creation of Docker images for your Flask application with every push, ensuring faster deployments and a seamless CI/CD pipeline.

Ready for Part 2? Click here to continue.