Linux server management: How to use Docker for rapid deployment and scaling?

Linux server management: How to use Docker for rapid deployment and expansion?

Introduction:
With the development of cloud computing and containerization technology, Docker, as a lightweight virtualization tool, has become the first choice of many developers and operation and maintenance personnel. This article will introduce how to use Docker for rapid deployment and expansion on Linux servers to improve the operating efficiency and scalability of applications.

1. Installing Docker
   Before we begin, we first need to install Docker on the Linux server. Please follow the steps below to install:

Step 1: Update server software package

$ sudo apt-get update

Step 2: Install Docker dependencies

$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

Step 3: Add Docker official GPG Key

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Step four: Add Docker repository

$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Step five: Update package index and install Docker

$ sudo apt-get update
$ sudo apt-get install docker-ce

2. Write Dockerfile
   In use Before Docker, we need to write a Dockerfile to define how to build a Docker image. The following is a sample Dockerfile:

# 使用基础镜像
FROM ubuntu:latest

# 设置作者信息
MAINTAINER Your Name <your@email.com>

# 安装相关依赖
RUN apt-get update && apt-get install -y 
    python3 
    python3-pip

# 设置工作目录
WORKDIR /app

# 将应用程序添加到镜像中
COPY . /app

# 安装应用程序依赖
RUN pip3 install -r requirements.txt

# 设置容器启动命令
CMD ["python3", "app.py"]

In the above example, we used a latest Ubuntu image as the base image. We then installed Python3 and the pip3 tools and copied the application folder to the image. Next, we install the application's dependencies and set the container startup command to run the app.py file.

3. Build the image
   After completing the writing of the Dockerfile, we can use the following command to build the Docker image:

$ docker build -t myapp:latest .

The above command will build a Docker image based on the definition in the Dockerfile An image named myapp and marked as the latest version.

4. Run the container
   After building the image, we can use the following command to run the container:

$ docker run -d -p 80:5000 myapp:latest

The above command will start a container running in background mode , and map port 80 of the host to port 5000 of the container. In this way, we can access the application through the browser to port 80 of the host.

5. Scaling Applications
   Using Docker makes it easy to scale applications, which can increase system availability and throughput through multiple container instances. Here is a simple implementation example:

First, we need to use Docker Compose to define the entire architecture of the application. Create a file called docker-compose.yml and add the following content:

version: '3'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: myapp:latest
    ports:
      - "80:5000"

  load_balancer:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - app

In the above example, we defined two services: app and load_balancer. The app service will build the image based on the Dockerfile in the current directory and map the container's 5000 port to the host's port 80. The load_balancer service will use the Nginx image and map port 80 of the host to port 80 of the container.

Next, we need to create a configuration file named nginx.conf and add the following content:

upstream app_servers {
    server app:5000;
}

server {
    listen 80;
    location / {
        proxy_pass http://app_servers;
    }
}

The above configuration file defines an upstream named app_servers and uses proxy_pass to Forward the request to the app service.

Finally, use the following command to run multiple instances of the application:

$ docker-compose up --scale app=3

The above command will run 3 app container instances and use Nginx as a load balancer for traffic distribution.

Conclusion:
By using Docker, we can quickly deploy and scale applications easily. By writing a Dockerfile to define image building steps, using the docker run command to run containers, and using Docker Compose for multi-container management, we can manage and scale applications more efficiently. I hope this article can help you use Docker to deploy and expand on Linux servers.

The above is the detailed content of Linux server management: How to use Docker for rapid deployment and scaling?. For more information, please follow other related articles on the PHP Chinese website!