devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【DevOps系列】构建Devops系统_企业devops怎么做的

作者：神奇cpp | 2024-07-30 11:20:30

赞

踩

企业devops怎么做的

开始介绍

那就着手开始干吧。先介绍一下我们的工具链。

主要工具：GitHub、Jenkins、Kubernetes、Ansible、Prometheus和JMeter

着手动

1. 设置GitHub作为源代码仓库

  1. 登录GitHub: 打开浏览器并访问 https://github.com，使用您的GitHub账户登录。

  2. 创建新的仓库: 登录后，您应该能看到GitHub的主页。点击页面右上角的 "+" 符号，然后选择 "New repository" 或直接在导航栏中找到 "Repositories" 并点击 "New"。

  3. 填写仓库信息: 在新弹出的页面中，您会被要求填写一些关于仓库的基本信息：

    • Repository name: 输入仓库的名称。这将是您的项目在GitHub上的标识。
    • Description: 可选地，您可以为仓库添加一个描述，解释其用途或内容。
    • Visibility: 选择仓库的可见性。您可以选择 "Public"（公开）或 "Private"（私有）。私有仓库需要付费订阅。
    • Add a README file: 选中此选项将自动为您的仓库添加一个README文件，这是仓库的默认说明文件。
    • Add .gitignore: 如果适用，可以选择添加一个.gitignore文件，这将帮助您忽略特定类型的文件或目录，例如编译后的文件或操作系统特定的缓存文件。
    • Add a license: 如果您的项目遵循某种开源许可证，这里可以选择添加一个许可证模板。

  4. 创建仓库: 填写完所有必要的信息后，点击页面底部的 "Create repository" 按钮。

  5. 初始化本地仓库: 创建仓库后，GitHub会显示初始化本地仓库的命令。您需要在本地机器上安装Git，并在您希望存放项目代码的目录中运行以下命令：

    git init

    初始化完成后，使用以下命令将本地仓库与GitHub仓库关联：

    git remote add origin https://github.com/yourusername/your-reponame.git

  6. 推送代码到GitHub: 将您的代码添加到本地仓库中，然后使用以下命令将代码推送到GitHub：

    1. git add .
    2. git commit -m "Initial commit"
    3. git push -u origin main

2. 配置Jenkins作为持续集成/持续交付服务器

步骤1: 安装Jenkins

  1. 下载Jenkins: 访问Jenkins官方网站 Download and deploy 下载适合您操作系统的Jenkins安装包。
  2. 安装Jenkins:
    • Linux: 使用RPM或DEB包安装，或通过Docker容器运行。
    • Windows: 下载Windows安装程序并运行。
    • macOS: 可以通过Homebrew安装。
  3. 启动Jenkins: 根据您的操作系统，使用相应的命令或服务管理工具启动Jenkins。
  4. 初始化Jenkins: 第一次启动时，Jenkins会引导您完成初始化过程，包括解锁Jenkins和设置管理员密码。

步骤2: 配置Jenkins

A. 解锁Jenkins
  1. 获取初始管理员密码: Jenkins会提示您从 /var/lib/jenkins/ 目录下的密钥文件中获取初始密码。
  2. 输入密码解锁: 在浏览器中输入密码解锁Jenkins。
B. 安装插件
  1. 安装推荐插件: Jenkins会推荐一组插件，选择 “Install” 安装它们。
  2. 安装额外插件: 根据项目需求，可能需要安装额外的插件，如 GitHub Plugin, Git Plugin, Kubernetes Plugin, Docker Pipeline Plugin 等。
C. 创建第一个管理员用户
  1. 设置用户名和密码: 创建一个新的管理员账户。
  2. 保存设置: 完成后，保存并完成初始化过程。

步骤3: 创建Jenkins Job

  1. 新建Job: 在Jenkins主页点击 “New Item”。
  2. 选择Job类型: 选择适合的类型，如 “Freestyle project” 或者 “Pipeline”。
  3. 配置Job:
    • General: 给Job命名，添加描述。
    • Source Code Management: 配置源代码管理，如 Git，指定仓库URL、分支等。
    • Build Triggers: 设置触发构建的条件，如代码提交、定时任务等。
    • Build Environment: 可以在这里设置环境变量或脚本。
    • Build Steps: 添加构建步骤，如执行shell命令、调用Maven或Gradle命令等。
    • Post-build Actions: 配置构建后的动作，如发送邮件通知、部署到Kubernetes等。
    • Save: 保存配置。

步骤4: 集成GitHub

  1. 安装GitHub Plugin: 如果还未安装，确保已经安装了GitHub Plugin。
  2. 配置GitHub Credentials: 在Jenkins的全局配置中添加GitHub的访问令牌。
  3. 配置Job: 在Job配置中，选择GitHub作为源代码管理，并使用前面创建的Credentials。

步骤5: 测试和优化

  1. 手动触发构建: 开始手动触发构建，检查是否一切正常。
  2. 自动化构建: 设置自动化触发，如通过GitHub webhook来自动触发构建。
  3. 监控和日志: 查看构建日志，监控构建状态，确保没有错误发生。

步骤6: 部署至Kubernetes

  1. 配置Kubernetes Plugin: 安装Kubernetes Plugin，如果还未安装的话。
  2. 添加Kubernetes Credentials: 在Jenkins中添加Kubernetes集群的凭证。
  3. 配置部署步骤: 在Job的构建步骤中添加Kubernetes部署命令。

通过以上步骤，就可以配置好Jenkins作为持续集成和持续交付的服务器了。确保在实际操作中，根据您的具体需求和环境进行适当的调整。

3. 部署Kubernetes集群

配置Kubernetes集群，对于一个普通的团队而言，最划算的是直接使用云服务商提供的云服务器，这样也不用麻烦自己搭建。但是如果想要自己搭建的话，也是可以的，这边介绍使用kubeadm来搭建kubernetes集群。

准备工作

  1. 服务器准备:

    • 确保每台服务器或虚拟机都满足Kubernetes的系统要求。
    • 每台机器上都需要安装Linux操作系统（如CentOS、Ubuntu等）。

  2. 关闭防火墙和SELinux: 这是为了简化安装过程，但在生产环境中，你可能需要配置防火墙规则而不是完全禁用它。

    1. sudo systemctl stop firewalld
    2. sudo systemctl disable firewalld
    3. sudo setenforce 0
    4. sudo sed -i 's/^SELINUX=enforcing$/SELINUX=disabled/' /etc/selinux/config

  3. 禁用Swap: Kubernetes不支持在有活跃swap的系统上运行。

    sudo swapoff -a

安装Kubernetes

  1. 安装必要的软件包:

    sudo apt-get update && sudo apt-get install -y apt-transport-https curl

  2. 添加Kubernetes的GPG密钥:

    curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

  3. 添加Kubernetes的APT仓库:

    1. cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
    2. deb https://apt.kubernetes.io/ kubernetes-xenial main
    3. EOF

  4. 安装Kubernetes的组件:

    sudo apt-get update && sudo apt-get install -y kubelet kubeadm kubectl

配置和初始化主节点

  1. 初始化Master节点:

    sudo kubeadm init --pod-network-cidr=<CIDR>

    <CIDR>应替换为你的Pod网络CIDR，例如10.244.0.0/16。

  2. 设置kubeconfig: 初始化完成后，kubeadm init会输出一些信息，包括一个kubectl配置文件的位置。你需要把这个配置文件复制到你的用户主目录下。

    1. mkdir -p $HOME/.kube
    2. sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
    3. sudo chown $(id -u):$(id -g) $HOME/.kube/config

加入Worker节点

  1. 运行kubeadm join命令: 在初始化Master节点后，kubeadm init会输出一个kubeadm join命令。在每个Worker节点上运行这个命令以加入集群。

配置网络插件

  1. 安装网络插件: 通常使用像Flannel、Calico或Weave Net这样的网络插件。以Flannel为例： 
    kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

验证集群状态

  1. 检查节点状态:

    kubectl get nodes

  2. 检查集群状态:

    1kubectl cluster-info

以上步骤提供了搭建Kubernetes集群的基本流程。在生产环境中，你可能还需要考虑更多因素，如高可用性、安全性和性能优化等。另外，许多云服务商如AWS、Google Cloud和Azure都提供了托管的Kubernetes服务，可以大大简化部署和维护的复杂度。

4. 使用Ansible自动化部署

配置Ansible用于自动化部署通常涉及到以下几个关键步骤：

  1. 安装Ansible 首先确保Ansible已经安装在你的控制节点（即运行Ansible命令的机器）上。如果你还没有安装，可以在Linux系统上使用如下命令进行安装：

    1. sudo apt update
    2. sudo apt install ansible

  2. 配置Ansible Ansible的配置文件通常位于/etc/ansible/ansible.cfg，你可以在此文件中修改一些默认配置，例如SSH超时时间、重试次数等。

  3. 创建Inventory文件 Inventory文件是用来定义目标主机列表以及它们的变量的地方。可以使用INI格式或YAML格式。例如：

    1. [webservers]
    2. host1.example.com
    3. host2.example.com
    4.  
    5. [dbservers]
    6. db1.example.com
    7. db2.example.com

    或者使用动态inventory脚本。

  4. 编写Playbooks Playbooks是Ansible的核心，使用YAML语法编写，用来定义要执行的任务序列。例如，一个简单的playbook可能看起来像这样：

    1. - name: Deploy web application
    2.   hosts: webservers
    3.   become: yes
    4.   tasks:
    5.     - name: Update apt cache
    6.       apt:
    7.         update_cache: yes
    8.  
    9.     - name: Install Apache
    10.       apt:
    11.         name: apache2
    12.         state: latest
    13.  
    14.     - name: Copy HTML files
    15.       copy:
    16.         src: ./html_files/
    17.         dest: /var/www/html/
    18.         owner: www-data
    19.         group: www-data
    20.         mode: 0644
    21.  
    22.     - name: Restart Apache
    23.       service:
    24.         name: apache2
    25.         state: restarted
    26.         enabled: yes

  5. 执行Playbook 使用ansible-playbook命令来执行playbook：

    1ansible-playbook -i inventory.ini deploy_webapp.yml

  6. 使用Role和Modules Ansible的Role提供了一种组织playbook的方式，使得代码更加模块化和可重用。Modules则是Ansible执行特定任务的小型程序。

  7. 测试和调试 使用--check选项来测试playbook是否会按预期工作，而不做任何更改：

    1ansible-playbook -i inventory.ini deploy_webapp.yml --check

  8. 优化和维护 随着Ansible playbooks的增加，你可能需要优化它们以适应不断变化的需求，比如添加错误处理、使用变量、模板化配置文件等。

  9. 集成CI/CD 将Ansible集成到持续集成/持续交付（CI/CD）管道中，例如与Jenkins、GitLab CI/CD或CircleCI配合使用，以便在代码变更时自动执行部署。

  10. 安全和权限 确保Ansible操作的安全性，例如使用become关键字来提升权限，使用Vault加密敏感信息，以及限制谁可以执行Ansible操作。

5. 配置Prometheus和Grafana进行监控

1. 安装Prometheus

首先，你需要在一台服务器上安装Prometheus。Prometheus可以从其官方网站下载适用于不同操作系统的二进制文件。以下是在Linux上安装Prometheus的简要步骤：

下载Prometheus
  1. wget https://github.com/prometheus/prometheus/releases/download/v<version>/prometheus-<version>.linux-amd64.tar.gz
  2. tar xvfz prometheus-<version>.linux-amd64.tar.gz
移动文件到适当位置
  1. sudo mv prometheus-<version>.linux-amd64/prometheus /usr/local/bin/prometheus
  2. sudo mv prometheus-<version>.linux-amd64/promtool /usr/local/bin/promtool
  3. sudo rm -rf prometheus-<version>.linux-amd64
创建配置文件
sudo nano /etc/prometheus/prometheus.yml

然后在配置文件中添加目标监控的job和scrape配置。

2. 启动Prometheus

启动Prometheus，通常使用systemd或作为Docker容器运行。

使用systemd
sudo nano /etc/systemd/system/prometheus.service

在文件中添加Prometheus服务的定义，保存并重新加载systemd配置，然后启动Prometheus。

  1. sudo systemctl daemon-reload
  2. sudo systemctl start prometheus
  3. sudo systemctl enable prometheus

3. 安装Grafana

Grafana可以从其官方网站下载或通过包管理器安装。

使用APT安装
  1. 1sudo apt-get install -y adduser libfontconfig1
  2. 2wget https://dl.grafana.com/oss/release/grafana_8.0.0_amd64.deb
  3. 3sudo dpkg -i grafana_8.0.0_amd64.deb
启动Grafana
  1. sudo systemctl start grafana-server
  2. sudo systemctl enable grafana-server

4. 配置Grafana

打开浏览器，访问Grafana的Web界面，默认地址是 http://localhost:3000，使用默认的用户名和密码登录（admin/admin）。

添加数据源

在Grafana中添加Prometheus作为数据源。

创建仪表板

使用Grafana创建新的仪表板，并添加图表来展示Prometheus收集的数据。

5. 配置Exporter和Target

如果需要监控特定的应用或服务，可能需要安装相应的Exporter。例如，对于Node Exporter、Blackbox Exporter或其他特定的服务Exporter。

6. 配置Alerting（可选）

如果需要配置警报，可以使用Prometheus的Alertmanager，配置规则并设定警报条件。

请注意，实际配置可能会因具体需求和环境而异，上述步骤提供了基础框架。在生产环境中，你可能需要更详细的规划，如安全性、持久存储、高可用性和扩展性等方面的考虑。

6. 使用JMeter进行性能测试

6. 运行测试计划

完成配置后，点击工具栏上的绿色三角形图标（运行按钮）或选择 "Run -> Start" 来运行测试计划。

7. 分析结果

测试运行完成后，使用 "View Results Tree" 或 "Aggregate Report" 等监听器来查看和分析测试结果。

  1. 1. 安装 Java

    JMeter 是基于 Java 构建的，因此首先需要在你的计算机上安装 Java Development Kit (JDK)。你可以从 Oracle 的官方网站下载最新版本的 JDK，并按照指示进行安装。安装完成后，确保设置好环境变量，使 java 命令可以在命令行中全局调用。

    2. 下载和安装 JMeter

    访问 Apache JMeter 的官方网站下载最新版本的 JMeter ZIP 包。解压缩下载的 ZIP 文件到你希望存放 JMeter 的目录。

    3. 配置 JMeter 属性

    在 JMeter 目录下的 bin 文件夹中，找到 jmeter.properties 文件。使用文本编辑器打开它，你可以在这里配置各种 JMeter 的行为。例如，如果你想将界面语言更改为中文，可以取消注释 language=zh_CN 这一行。

    4. 运行 JMeter

    打开命令行或终端，导航到 JMeter 的 bin 目录，并运行 jmeter.sh（Unix/Linux）或 jmeter.bat（Windows）。这将启动 JMeter 的图形界面。

    5. 创建测试计划

    一旦 JMeter 运行起来，你可以开始创建测试计划。测试计划是所有测试元素的容器，包括线程组、采样器、监听器等。

    步骤如下：

  2. 新建测试计划：

    • 选择 "Test Plan" 并从上下文菜单中选择 "Add -> Logic Controller -> Simple Controller" 来添加逻辑控制器（如果需要）。

  3. 添加线程组：

    • 在测试计划或逻辑控制器下添加 "Thread Group"，这将定义测试的并发用户数和循环次数。

  4. 添加采样器：

    • 在线程组下添加 "Sampler"，如 "HTTP Request Default"，用于向目标服务器发送请求。
    • 配置请求的 URL、方法、参数等。

  5. 添加监听器：

    • 添加 "Listener" 如 "View Results Tree" 或 "Summary Report"，以便观察和分析测试结果。

  6. 配置其他元素：

    • 根据需要添加断言、定时器、配置元件等。

7. 整合所有组件

使用Jenkins Pipeline as Code功能，可以将构建、测试和部署的步骤整合成一个自动化流水线。下面是一个示例，展示了如何使用Declarative Pipeline语法来实现这一过程，该流水线包括构建、单元测试、集成测试、静态代码分析、打包、部署以及使用Prometheus和Grafana进行监控。

Jenkinsfile 示例

在项目根目录中创建一个名为 Jenkinsfile 的文件，然后输入以下内容：

  1. pipeline {
  2.     agent any
  3.     environment {
  4.         DOCKER_REGISTRY = "your-docker-registry-url"
  5.         IMAGE_NAME = "your-image-name"
  6.         TAG = "${env.BUILD_NUMBER}"
  7.     }
  8.  
  9.     stages {
  10.         stage('Build') {
  11.             steps {
  12.                 script {
  13.                     sh 'mvn clean package'
  14.                 }
  15.             }
  16.         }
  17.  
  18.         stage('Test') {
  19.             steps {
  20.                 script {
  21.                     sh 'mvn test'
  22.                 }
  23.             }
  24.             post {
  25.                 always {
  26.                     junit 'target/surefire-reports/*.xml'
  27.                 }
  28.             }
  29.         }
  30.  
  31.         stage('Static Analysis') {
  32.             steps {
  33.                 script {
  34.                     sh 'mvn checkstyle:checkstyle'
  35.                 }
  36.             }
  37.             post {
  38.                 always {
  39.                     archiveArtifacts 'target/checkstyle-result.xml'
  40.                     publishHTML target: [
  41.                         allowMissing: true,
  42.                         alwaysLinkToLastBuild: false,
  43.                         keepAll: true,
  44.                         reportDir: 'target/site/checkstyle',
  45.                         reportFiles: 'index.html',
  46.                         reportName: 'Checkstyle Report',
  47.                         reportTitles: ''
  48.                     ]
  49.                 }
  50.             }
  51.         }
  52.  
  53.         stage('Package') {
  54.             steps {
  55.                 script {
  56.                     sh 'docker build -t ${IMAGE_NAME}:${TAG} .'
  57.                     sh 'docker tag ${IMAGE_NAME}:${TAG} ${DOCKER_REGISTRY}/${IMAGE_NAME}:${TAG}'
  58.                     sh 'docker push ${DOCKER_REGISTRY}/${IMAGE_NAME}:${TAG}'
  59.                 }
  60.             }
  61.         }
  62.  
  63.         stage('Deploy') {
  64.             steps {
  65.                 script {
  66.                     sh 'kubectl apply -f kubernetes/deployment.yaml'
  67.                     sh 'kubectl apply -f kubernetes/service.yaml'
  68.                 }
  69.             }
  70.         }
  71.  
  72.         stage('Prometheus & Grafana Setup') {
  73.             steps {
  74.                 script {
  75.                     sh 'kubectl apply -f monitoring/prometheus.yml'
  76.                     sh 'kubectl apply -f monitoring/grafana.yml'
  77.                 }
  78.             }
  79.         }
  80.     }
  81.  
  82.     options {
  83.         timeout(time: 30, unit: 'MINUTES')
  84.     }
  85.  
  86.     triggers {
  87.         pollSCM('*/30 * * * *')
  88.     }
  89. }
  • Agent：指定流水线应该在哪个节点上运行。
  • Environment：定义流水线中使用的环境变量。
  • Stages：流水线中的各个阶段。
  • Steps：每个阶段执行的具体操作。
  • Post：阶段结束后执行的操作，例如收集测试报告、静态分析报告等。
  • Options：定义流水线的额外选项，例如超时时间。
  • Triggers：触发流水线执行的条件，例如定期执行或代码提交时。

这样，整条流水线就可以转起来了。当然，中间的细节，需要依照实际的情况进行调整，不过这边整个devops平台基本就是 完整了。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/903489
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号