How to configure continuous integration and continuous deployment (CI/CD) on Linux

How to configure continuous integration and continuous deployment (CI/CD) on Linux

In modern software development, continuous integration and continuous deployment (CI/CD) have become essential in the development process of many teams a part of. They help developers build, test, and deploy code quickly and efficiently. This article will introduce how to configure continuous integration and continuous deployment on Linux systems, and provide some code examples to help readers better understand.

1. Install the necessary tools and dependencies

First of all, installing the necessary tools and dependencies on the Linux system is the first step in configuring the CI/CD process. Among them, the most common tools are Git, Docker and Jenkins. The following are sample commands to install these tools on Ubuntu systems:

# 安装Git
sudo apt update
sudo apt install git

# 安装Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 安装Jenkins
wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt update
sudo apt install jenkins

2. Create a Github repository

Next, we need to create a repository on Github to store our code. Suppose our code repository is named my-project. Create a new repository on Github and clone it locally:

git clone https://github.com/your-username/my-project.git

3. Write and test the code

In the cloned local repository, write and test your code code. In this example, we use a simple Python program to demonstrate:

# app.py
def hello_world():
    return "Hello, World!"

print(hello_world())

# 运行测试
python app.py

4. Creating a Docker image

The next step is to create a Docker image to containerize the application ized and easily deployed in different environments. Create a file named Dockerfile in the code repository and add the following content:

# 基于Python的Docker镜像
FROM python:3.8

# 复制代码到容器中
COPY app.py /app/app.py

# 设置工作目录
WORKDIR /app

# 安装依赖项
RUN pip install flask

# 暴露端口
EXPOSE 5000

# 运行应用程序
CMD [ "python", "app.py" ]

Then, use the following command to build and run the Docker image:

# 构建Docker镜像
docker build -t my-app .

# 运行Docker容器
docker run -p 5000:5000 my-app

5. Configure Jenkins

Now that we have a working Docker container, we need to configure Jenkins to automatically build, test and deploy our code. Open your browser and visit http://localhost:8080 to open the Jenkins management interface. Follow the on-screen instructions to complete the initial setup.

Next, we need to install some Jenkins plugins to support Docker and Git integration. On the Jenkins management interface, click "Plug-in Management" and then select "Optional Plug-ins". Search and install the following plugin:

• Git Plugin
• Docker Plugin
• Pipeline Plugin

6. Create Jenkins Pipeline

On the homepage of the Jenkins management interface, click "New Task" to create a new Jenkins Pipeline. Select the Pipeline project and give it a name, such as my-pipeline. In the "Pipeline" tab, select "Pipeline script from SCM" and fill in the following information:

• SCM: Git
• Repository URL: https://github.com/ your-username/my-project.git
• Script Path:Jenkinsfile

Create a file named Jenkinsfile and add the following content:

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                sh "docker build -t my-app ."
            }
        }
        stage('Test') {
            steps {
                sh "docker run my-app python app.py"
            }
        }
        stage('Deploy') {
            steps {
                sh "docker run -d -p 5000:5000 my-app"
            }
        }
    }
}

7. Run Jenkins Pipeline

Save and submit the code and Jenkinsfile to the Github repository. Then, return to the Jenkins management interface, click on the my-pipeline task, and select "Build Now" to run the Jenkins Pipeline. Jenkins will automatically clone the code, build Docker images, run tests and deploy the application.

By visiting http://localhost:5000, you should be able to see the successfully deployed application.

Summary

Through the above steps, we successfully configured a simple CI/CD process on the Linux system. When changes are made to the code base, Jenkins will automatically build, test, and deploy the application. The tools used in this example are just one combination, and the actual configuration may vary based on the specific needs of your project. However, this example can be used as a starting point to help you start using continuous integration and continuous deployment to improve development efficiency.

The above is the detailed content of How to configure continuous integration and continuous deployment (CI/CD) on Linux. For more information, please follow other related articles on the PHP Chinese website!