DevOps 实验手册

等待实验手册？

目前，我的几个好朋友即将参加 DevOps 考试。由于学校提供的教材匮乏，加上老师水平不高，这门课很快就成了他们的噩梦。

别担心，因为我是被召唤来应对这场危机的。是时候尊重一下 DevOps 了，同时也试着让一些朋友的生活更轻松一些。

注意：本讲义将包含以下所有 6 个问题的解决方案和解释：

本指南不仅可以帮助那些参加课程代码22CBL54的人，而且可以帮助任何想要进入 devops 的人。

介绍

我是 Akash Singh，来自班加罗尔，工程专业三年级学生，也是一位开源贡献者。我的LinkedIn、GitHub和Twitter 账号
如下：

我在网上使用的名字是 SkySingh04。

DevOps 又是什么？

DevOps 是一个你无法逃避的流行词，而且理由充分。它是开发和运维的融合——一种旨在通过改善开发人员和 IT 运维团队之间的协作来简化软件开发生命周期 (SDLC) 的方法。

可以将 DevOps 视为一个配方，其中：

Dev = 制作菜肴（编码）
运营 = 为用户提供热腾腾的服务（部署和维护）

你为什么要关心？

速度：更快地交付功能。
协作：不再互相指责——“它在我的计算机上可以运行”在这里行不通。
可靠性：生产过程中的错误更少（敲木头）。
可扩展性：像老板一样处理用户流量。
安全性：自动化无趣但重要的安全检查。

希望你理解我的意思吧？基本上，如果应用在生产环境中崩溃了，他们首先会来找我麻烦，问我出了什么问题。作为一名 DevOps 工程师，既然我已经设置好了部署的流水线，我应该能够查看监控工具、日志或基础设施，然后告诉他们，是这个人搞砸了（90% 是开发人员搞砸的，10% 是我在设置基础设施或流水线时搞砸的，呵呵）。

好吧，我希望现在说得通了，基本上我们 devops 工程师是一个混合体，并且认为我们是主角。

好的，现在前提已经确定，让我们开始通过这个实验室的内部情况吧？

问题一：GIT操作

问题陈述

执行 Git 操作，例如创建存储库以及获取、拉取和分支。

解决方案

步骤1：安装Git

像专业人士一样使用您的终端：

sudo apt update
sudo apt install git

第 2 步：创建存储库

导航到您的项目文件夹：
```
cd ~/your_project
```
初始化 Git：
```
git init
```

添加并提交文件：

git add .
git commit -m "Initial commit"

步骤 3：获取并拉取

Fetch从远程存储库带来更改但并不合并它们：
```
git fetch origin
```
拉取并合并更改：
```
git pull origin main
```

步骤 4：分支

创建新分支：
```
git branch feature-branch
```
切换到它：
```
git checkout feature-branch
```

合并回主目录：

git checkout main
git merge feature-branch

总的来说，这个程序解释得相当清楚。我希望读这篇文章的人一生中用过git一次。对三年级学生来说，这要求太高了吗？Sky，你有没有想过这个问题？

问题 2：DevOps 生命周期

DevOps 生命周期涉及一系列阶段——编码、构建、测试、配置和监控——旨在简化软件开发流程。

代码：协作编写和管理代码。
构建：将源代码编译成可执行文件。
测试：自动化测试以确保代码质量。
配置：设置部署环境。
监控：跟踪生产中的应用程序健康状况。

好了，我们将构建一个非常小的Web应用程序，显示“Hello, Devops!”，然后在其中实现上述5个步骤。

这个问题有点模糊，实现和回答的方法有百万种。我尽量给出一个最简单的方案，最好能拿到满分，否则我就删掉我的领英。

步骤 1：代码

创建Flask应用程序
File: app.py

from flask import Flask    
app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, DevOps!"

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5000)

设置虚拟环境

python3 -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate  # Windows

pip install flask

pip freeze > requirements.txt

运行应用程序
python app.py
在浏览器中打开：http://localhost:5000。

第 2 步：构建

如果你知道的话，Python 是一种解释型语言。它没有所谓的“构建”步骤，因为代码是逐行执行的。所以这里的“构建”指的是环境的准备，并确保应用程序已准备好运行。

我们将编写一个简单的shell 脚本（build.sh）来安装依赖项并确保应用程序运行：

#!/bin/bash
echo "Setting up environment..."
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
echo "Environment setup complete. Run the app with: python app.py"

运行脚本：
```
bash build.sh
```

步骤3：测试

现在，由于程序要求我们编写一些测试，我们将编写一个非常简单的测试来检查应用程序是否正在运行。顺便说一句，这是一个无耻的插件，但如果你想用零代码编写测试，请查看我的Keploy Vscode 扩展 xD

**测试文件（test_app.py）：

import unittest
from app import app

class TestApp(unittest.TestCase):
    def test_home(self):
        tester = app.test_client(self)
        response = tester.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data, b"Hello, DevOps!")

if __name__ == "__main__":
    unittest.main()

运行测试：
```
python -m unittest test_app.py
```

步骤4：配置

这里的配置重点是确保应用程序可以在不同的环境中运行。一种简单的方法是使用环境变量。

创建 .env 文件：
```
FLASK_PORT=5000
```

修改app.py读取环境变量：

import os
from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, DevOps!"

if __name__ == "__main__":
    port = int(os.getenv("FLASK_PORT", 5000))
    app.run(port=port)

使用 python-dotenv 自动加载 .env 文件：
```
pip install python-dotenv
```

添加到app.py：

from dotenv import load_dotenv

load_dotenv()

步骤5：监控

现在，当你引入像 Prometheus、Grafana、Loki 等高级工具时，监控会变得非常复杂。实现所有这些工具超出了本入门指南的范围。一般来说，监控只是查看应用程序运行时的操作，例如日志、运行状况、任何错误等。我们将集成一些无需外部工具的基本监控功能：

添加 /health 端点来检查应用程序是否正在运行：

@app.route('/health')
def health():
    return {"status": "up"}, 200

将请求记录到文件中：

import logging

logging.basicConfig(filename='app.log', level=logging.INFO)

@app.before_request
def log_request():
    logging.info(f"Request: {request.method} {request.path}")

现在，当教员询问监控在哪里时，向他显示 localhost:5000/health 路径和 app.log 文件。让他高兴就好，因为如果我们想让监控变得花哨，事情可能会变得非常复杂。

那么我们到底做了什么？

代码：使用基本编码实践构建的 Python Flask 应用程序。
构建：使用 venv 和构建脚本准备环境。
测试：使用 Python 的 unittest 来验证应用程序的行为。
配置：使用 .env 和 python-dotenv 管理环境变量。
监控：添加了 /health 端点和请求日志记录。

这就是我们轻松实现 DevOps 的方法！🎉

问题 3：与 Jenkins 进行持续集成

那么，Jenkins 这个新玩意儿到底是什么？还记得我说过，作为一名 DevOps 人员，我必须设置流水线来确保应用/代码能够部署吗？没错，所以这个流水线通常是用 GitHub Actions 构建的，在一些比较高端的公司，他们会用一个叫Jenkins 的工具。

安装Jenkins的步骤：

这应该已经在你的实验室系统中完成了，如果没有，请告诉你的老师，你没有安装 jenkins，或者在线查找安装说明，不要记住这些。只需要启动 jenkins 的命令。
记住，你需要一个现有的应用程序才能使用 jenkins 进行部署，为了简单起见，我使用了我们在第二季度构建的同一个 Python 应用程序。你需要将它推送到 GitHub，因为你需要将管道连接到你的代码库。

安装 Java（Jenkins 必需）：

sudo apt update
sudo apt install openjdk-11-jdk

添加 Jenkins 存储库：

curl -fsSL https://pkg.jenkins.io/debian/jenkins.io.key | sudo tee \
/usr/share/keyrings/jenkins-keyring.asc > /dev/null
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
https://pkg.jenkins.io/debian binary/ | sudo tee 
/etc/apt/sources.list.d/jenkins.list > /dev/null

安装 Jenkins：

sudo apt update
sudo apt install jenkins

启动 Jenkins 并检查状态：

sudo systemctl start jenkins
sudo systemctl status jenkins

配置 Jenkins

访问 Jenkins：

打开浏览器并转到 http://:8080 或http://localhost:8080。
解锁詹金斯：

使用以下位置的管理员密码：（无法记住，密码始终是唯一的，您可以在这里找到它）
```
cat /var/lib/jenkins/secrets/initialAdminPassword
```
安装推荐的插件：

按照屏幕上的设置安装必要的插件（例如，Git、NodeJS、Pipeline）。

Web 应用程序的 Jenkins 管道

创建新作业：

-   Go to Jenkins Dashboard and click *"New Item"*.
-   Choose *"Pipeline"* and give it a name.

配置 Git 存储库：

-   In the Pipeline configuration, specify the repository URL:
    -   *Source Code Management* > Select *Git* > Enter your repository URL.
-   Add credentials if needed.

定义管道脚本：

pipeline {
    agent any

    environment {
        VIRTUAL_ENV = 'venv' // Virtual environment directory
        FLASK_PORT = '5000' // Port to run the Flask app
    }

    stages {
        stage('Clone Repository') {
            steps {
                echo 'Cloning the repository...'
                git branch: 'main', url: 'https://github.com/ahanasrinath/myflaskapp.git'
            }
        }

        stage('Set Up Environment') {
            steps {
                echo 'Setting up virtual environment and installing dependencies...'
                sh '''
                python3 -m venv $VIRTUAL_ENV
                source $VIRTUAL_ENV/bin/activate
                pip install -r requirements.txt
                '''
            }
        }

        stage('Run Tests') {
            steps {
                echo 'Running unit tests...'
                sh '''
                source $VIRTUAL_ENV/bin/activate
                python -m unittest discover -s . -p "test_*.py"
                '''
            }
        }

        stage('Build and Package') {
            steps {
                echo 'Packaging the application...'
                sh '''
                tar -czf flask-app.tar.gz app.py requirements.txt .env
                '''
            }
        }

        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
                sh '''
                # Copy the application to the deployment server
                scp flask-app.tar.gz user@your-server:/path/to/deployment

                # SSH into the server and deploy
                ssh user@your-server << EOF
                cd /path/to/deployment
                tar -xzf flask-app.tar.gz
                source $VIRTUAL_ENV/bin/activate
                nohup python app.py > app.log 2>&1 &
                EOF
                '''
            }
        }
    }

    post {
        success {
            echo 'Pipeline completed successfully!'
        }
        failure {
            echo 'Pipeline failed. Check the logs for more details.'
        }
    }
}

现在问题来了……因为我们一开始就没有服务器，所以jenkins根本没地方部署我们的应用。这又让我疑惑了，他们为什么在完全没有部署到哪里的情况下就告诉你们部署东西？

学校会给你们专门的服务器部署吗？不太可能。他们知道需要这么做吗？也不太可能。所以，对最后的部署阶段持保留态度。

希望这不是考场里的你们，而是每天的我。

笔记：

如果他们给你一个随机的应用让你用 Jenkins 部署，*不要慌。你会发现，我们在 Jenkins 文件中写的任何步骤都是我们在第二季度执行的实际命令。因此，它们可以被替换为针对任何特定应用/技术栈的任何特定指令集。 *

例如：

如果他们给你一个 React 应用，那么安装环境会被替换为 just npm install，构建也会被替换为npm run build。同样，对于 Java 应用，它可能会有所不同，例如javac app.java或gcc main.cac 文件。

重点是不要慌张，他们不知道自己在教什么，也不知道自己在问什么问题。只要你把步骤写得和上面差不多，他们就知道你做了什么。

问题4：版本控制工具

Git 在这方面是王者，但CVS、RCS和Mercurial等替代方案也值得一提。它们各有优缺点：

RCS：适用于单文件项目。
CVS：老派，非常适合团队。
Mercurial：Git 不太出名的兄弟，受到 Mozilla 等项目的青睐。

Chalo，我们先安装一下这些（希望你们要用的实验室电脑上已经装好了）。Mac 请使用 brew 命令，Linux 请使用 apt 命令。

雷达反射截面

sudo apt install rcs

brew install rcs

CVS

sudo apt install cvs

brew install cvs

Git

sudo apt install git

brew install git

Mercurial

sudo apt install mercurial

brew install mercurial

以下是所有这些命令的基本命令：

1. 版本控制系统（RCS）

# Initialize RCS directory
mkdir RCS

# Check-in a file to create its first revision
ci -u filename

# Check-out a file for editing
co -l filename

# View version history
rlog filename

2. 并发版本系统（CVS）

# Initialize a repository
cvs -d /path/to/repo init

# Add a project to CVS
cvs import -m "Initial import" project_name vendor_tag release_tag

# Checkout a project
cvs checkout project_name

# Commit changes
cvs commit -m "Commit message"

3. Git

# Initialize a repository
git init

# Add files to the repository
git add .

# Commit changes
git commit -m "Initial commit"

# View history
git log

# Push changes to a remote repository
git remote add origin <repository-url>
git push -u origin main

4. Mercurial

# Initialize a repository
hg init

# Add files to the repository
hg add

# Commit changes
hg commit -m "Initial commit"

# View history
hg log

# Push changes to a remote repository
hg push <repository-url>

问题5：Docker基础知识

好吧，我们需要一点背景知识来解释Docker是什么。Docker 是每个 DevOps 工程师的必备技能。没有 Docker，就只有混乱、痛苦和煎熬。

什么是 Docker？

Docker 是一个开源平台，允许您在容器内开发、发布和运行应用程序。您可以将容器视为一个轻量级、可移植且一致的环境，其中包含应用程序运行所需的一切——代码、库、依赖项，甚至运行时。

为什么要使用 Docker？

本质上是为了解决“代码只是系统代码，而不是系统本身”的问题。Docker 容器模拟了整个环境及其所有依赖项，因此无论您在哪里运行容器，它都能可靠运行，不会出现任何意外。现在，您不必再与拥有 Mac 的富翁朋友或只使用 Linux 的宅男争论了。如果您喜欢代码，那就使用 Docker 吧。

Docker 的核心概念

Docker 镜像：
- 容器的蓝图。
- 包含应用程序代码、库和依赖项。
- 示例：我们将使用 Dockerfile 构建的图像。
Docker容器：
- Docker 镜像的正在运行实例。
- 独立、轻量、便携。
Dockerfile：
- 包含构建 Docker 镜像的说明的文本文件。
- 例子：
```
FROM python:3.8-slim
WORKDIR /app
COPY . .
CMD ["python", "app.py"]
```
Docker 中心：

-   A cloud-based registry for sharing Docker images.
-   Think of it as "GitHub for containers."

Docker 在 DevOps 中被广泛使用，因为它：

简化应用程序部署。
与 CI/CD 管道无缝协作。
允许微服务架构，其中每个服务在其自己的容器中运行。

强烈推荐观看Fireship 在 Docker 上的这个视频和Coderized的这个视频

用非常简单的话来说：想象一下你正在打包行李准备去旅行：

Docker Image是一个手提箱，预先装好了所有必需品（牙刷、衣服等）。
Docker 容器实际上就是你旅行时携带的行李箱。
Docker Hub是您购买预先包装好的行李箱（图像）的商店。

回到我们的实验程序，如何将我们的 Python 应用 docker 化？首先从这里下载 Docker Desktop

现在他们提到你应该运行不同的容器操作系统，这很简单：

1. 拉取操作系统镜像

Docker Hub 提供了各种各样的操作系统镜像。

搜索操作系统映像：

docker search <os-name>

Ubuntu 示例：

docker search ubuntu
拉取操作系统映像：

docker pull <os-name>:<tag>

Ubuntu 示例：

docker pull ubuntu:latest

2. 从操作系统镜像运行容器

运行交互式容器：

docker run -it <os-name>:<tag> /bin/bash

例子：

docker run -it ubuntu:latest /bin/bash

这将为您提供容器内的 shell 提示符。
列出正在运行的容器：

docker ps
列出所有容器（包括已停止的容器）：

docker ps -a
停止正在运行的容器：

docker stop <container-id>
移除容器：

docker rm <container-id>

3. 构建自定义应用程序容器

现在我们将 dockerise 你的 Flask 应用！上面的第 2 步对于此步骤来说不是必需的。

在根目录中创建 Dockerfile

FROM python:3.8-slim

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

构建 Docker 镜像

docker build -t flask-devops-app .
运行容器

docker run -d -p 5000:5000 flask-devops-app
通过http://localhost:5000访问该应用程序。

我仍然会写下每个步骤的作用，如果你能记住的话，请随意跳过：

FROM python:3.8-slim

目的：这指定了容器的基础图像。
- python:3.8-slim 是 Python 3.8 镜像的轻量级版本。它仅包含运行 Python 所需的基本组件，因此体积更小，下载速度更快。

WORKDIR /app

目的：将容器内的工作目录设置为 /app。
- 任何后续命令（如 COPY 或 RUN）都将相对于此目录执行。
- 它确保您的应用程序代码和依赖项保持在容器内的特定目录中。

COPY requirements.txt requirements.txt

目的：将 requirements.txt 文件从本地系统（主机）复制到容器内的 /app 目录。
- requirements.txt 文件包含您的应用程序所依赖的所有 Python 库。

RUN pip install -r requirements.txt

目的：

这将使用 pip 安装 requirements.txt 文件中指定的所有 Python 依赖项。
- 例如，如果您的应用程序使用 Flask，则 requirements.txt 可能包含：
  
  flask==2.1.2

COPY . .

目的：将所有文件从本地工作目录（主机）复制到容器内的 /app 目录。
- 它确保您的 app.py 和任何其他必要的文件（例如模板、静态资产）在容器中可用。

CMD ["python", "app.py"]

目的：指定容器启动时应运行的命令。
- 在这里，它告诉 Docker 执行 python app.py，从而启动你的 Flask 应用程序。
- CMD 命令在前台运行应用程序，以便在应用程序运行时保持容器处于活动状态。

就是这样！你的 DOCKER 应用现在运行成功了！

4.管理Docker容器和镜像

一些额外的命令，因为它们可能有用 yk

查看所有图片：

docker images
删除图像：

docker rmi <image-id>

停止并删除所有容器：

docker stop $(docker ps -aq)
docker rm $(docker ps -aq)

修剪未使用的数据（已停止的容器、网络等）：

docker system prune -a

问题 6：使用 Docker 部署应用程序

恭喜！如果你已经走到这一步，我真为你感到骄傲！你的奖励是：你不用再学习第6题了。没错，第5题和第6题的步骤完全一样！你也可以使用相同的第3步来部署相同的Flask应用。为了安全起见，这里也提供了Java实现，顺便说一下，你需要一个用Java编写的简单的Hello World程序，代码如下：

在项目目录中创建 Main.java

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Dockerized Java App!");
    }
}

然后在同一个文件夹中添加 Dockerfile：

Java 应用程序的 Dockerfile

FROM openjdk:11
COPY . /app
WORKDIR /app
RUN javac Main.java
CMD ["java", "Main"]

这里的步骤说明与我们的 Flask 应用程序的 Dockerfile 相同，只是我们使用 java 命令而不是 python 命令：

FROM openjdk:11

目的：这指定了容器的基础图像。
- openjdk:11 是一个轻量级图像，包含适用于 Java 11 的 Java 开发工具包 (JDK)。
- 它提供了编译和运行 Java 应用程序所需的一切。
- 使用特定版本（11）可确保一致性并避免因版本不匹配而出现的问题。

COPY . /app

目的：将主机上当前工作目录中的 所有文件复制到容器内的 /app 目录。
- 例如，这将包括您的 Java 源文件（Main.java）和运行应用程序所需的任何其他文件。

WORKDIR /app

目的：将容器内的工作目录设置为 /app。
- 所有后续命令（如 RUN 或 CMD）都将相对于此目录执行。
- 它确保您的应用程序文件在编译或执行之前位于正确的位置。

RUN javac Main.java

目的：这将使用容器内的 javac（Java 编译器）命令编译您的 Main.java 文件。
- javac 命令生成运行 Java 应用程序所必需的字节码 .class 文件（例如 Main.class）。
- 如果您的应用程序有多个 Java 文件或依赖项，请确保它们都已被复制并可供编译。

CMD ["java", "Main"]

目的：指定容器启动时应运行的命令。
- java Main 执行已编译的 Java 程序（Main.class）。
- CMD 在前台运行应用程序，确保容器在应用程序运行时保持活动状态。

构建并运行容器后，您的 Java 应用程序将执行并将结果输出到终端（或您的应用程序被编程发送结果的任何地方）。

构建并运行

构建图像：
```
docker build -t my-java-app .
```
运行容器：
```
docker run my-java-app
```
输出：

您应该看到：

Hello, World!!

结论

希望这篇博客能帮助大家顺利通过实验考试。写这篇博客并解答它真的很有趣，不知道你们老师如果没分享这些材料，整个学期都做了些什么。虽然网上都有这些资料，而且可能写得更好，解释得也更好，但我还是尽力用我自己的语言解释了，并解释了我如何解答所有问题。

再说一次，你的实验室系统会有网络。没有网络，你根本无法运行上述任何程序吧？所以，在考试期间，你可以很容易地在谷歌上搜索步骤或查阅这份讲义。

心存感激？我接受吉百利Fuse巧克力、芒果拉西，偶尔还会接受*ganne ka果汁。是的，这是我在Vance工作的一部分，也是我作为一名DevOps工程师的工作。是的，这在DevOps的海洋里只是沧海一粟，监控、Kubernetes、Yamls等等很快就会变得复杂起来。是的，我需要多接触一些，是的，所有读到这篇文章的朋友们*都热烈欢迎<3

感谢阅读:))

文章来源：https://dev.to/skysingh04/a-lab-manual-to-devops-4j0e