作者归档:TfcYe

百万级数据迁移方案测评小记

手把手教你把web应用丢到服务器上(单页应用+ 服务端渲染)

前言

最近公司在使用 ABP 重构之前的老项目,数据库也由 SQL SERVER 切换到了 MySql。吐槽一下,之前的产品使用的是 Windows Server 2008 , SqlServer 2008R2, .Net Framework 4.5,现在开始拥抱 .net core。回到正题。目前单表有 10w+100w+ 数据不等,等会都测试一下。数据库切换,以及数据库表结构变化,不可以避免的需要进行数据迁移。而迁移方案也并不是很多,下面是我尝试使用的两种方案进行测试。

多线程批量写入

private static async Task BatchInsertTestUsers(List<TestUser> testUsers)
        {
            var prefix =
                "INSERT INTO users (Id,Name,Age) VALUES";
            using (IDbConnection conn = new MySqlConnection(DataMigrationConfig.MySqlConstr))
            {
                var sqlText = new StringBuilder();
                sqlText.Append(prefix);

                foreach (var testUser in testUsers)
                {
                    sqlText.AppendFormat(
                        $"({testUser.Id},'{testUser.Name}', {testUser.Age}),");
                }

                var insertSql = sqlText.ToString().Substring(0, sqlText.ToString().LastIndexOf(','));
                await conn.ExecuteAsync(insertSql);
            }
        }
  • BatchInsertTestUsers 将传入的集合,拼接成 SQL 并执行。
public static Task RunMultiTasks(List<TestUser> users)
        {
            var tasks = new List<Task>();
            var pageSize = 10000;
            var writeCount = (users.Count() / pageSize) + 2;

            for (var i = 1; i < writeCount; i++)
            {
                var skipCount = (i - 1) * pageSize;
                var batchInsertList = users.Skip(skipCount).Take(pageSize).ToList();

                var task = Task.Run(() => { BatchInsertTestUsers(batchInsertList); });
                tasks.Add(task);
            }

            var sw = new Stopwatch();
            sw.Start();
            Task.WaitAll(tasks.ToArray());
            sw.Stop();
            Console.WriteLine($"多线程批量插入用时:{sw.ElapsedMilliseconds} ms");

            return Task.FromResult(0);
        }
  • RunMultiTasks 将数据分批,一次性插入 1w 条。

MySqlBulkLoader 方案

了解到 MySqlBulkLoader 是因为 SqlServerSqlbulkcopyMySqlBulkLoader 并不支持集合的导入,需要先将数据导出为 .csv 格式,然后读取 .csv 数据导入。

只需几行 JavaScript 代码,网页瞬间有气质了!

public static async Task Export(string filePath, List<TestUser> items)
        {
            IExporter exporter = new CsvExporter();
            await exporter.Export(filePath, items);
        }
  • 这里数据导出使用国人开源的 dotnetcore/Magicodes.IE 我这个导出代码,应该就懂了吧!操作简洁!!!
public static void Load(string filePath, string tableName)
        {
            using MySqlConnection conn = new MySqlConnection(DataMigrationConfig.MySqlConstr);
            var bulk = new MySqlBulkLoader(conn)
            {
                FieldTerminator = ",",
                FieldQuotationCharacter = '"',
                EscapeCharacter = '"',
                LineTerminator = "\r\n",
                FileName = filePath,
                Local = true,
                NumberOfLinesToSkip = 1,
                TableName = tableName,
                CharacterSet = "utf8mb4",
            };

            bulk.Load();
        }
  • 这里因为数据库并不在自己本机上,所以设置了 Local = true 读取本地文件,进行导入。

测试说明

  • 这个测试是在我本地测试的,数据库是跑在内网部署的一台机器上的 Docker 容器内,用的是机械硬盘。如果您的使用的是 SSD 硬盘,效果会更佳。
  • 这里测试主要是插入简单的用户数据,定义如下:
public class TestUser
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }
  • 分别测试1w10w,100w条数据插入的性能,以及开启索引以及关闭索引的影响
  • 测试执行代码如下:
class Program
    {
        static async Task Main(string[] args)
        {
            var testData = DataGen.Run(100 * 10000);
            await RunMultiTasks(testData);
            await RunMySqlLoaderTask(testData);
        }

        public static async Task RunMultiTasks(List<TestUser> users)
        {
            await DataMigrateTask.RunMultiTasks(users);
        }

        public static async Task RunMySqlLoaderTask(List<TestUser> users)
        {
            var fileName = "users";
            var filePath = Directory.GetCurrentDirectory() + "\\" + fileName + ".csv";
            await DataMigrateTask.Export(filePath, users);
            var sw = new Stopwatch();
            sw.Start();
            DataMigrateTask.Load(filePath, "users");
            sw.Stop();
            Console.WriteLine($"MySqlBulkLoader 用时:{sw.ElapsedMilliseconds} ms");
        }
    }

测试结果

说了那么多,这里才是最重点。

方案 1w 10w 100w
RunMultiTasks 367ms 3548ms 91263ms
RunMySqlLoaderTask 2031ms 1597ms 13105ms
RunMultiTasks(关闭索引) 233ms 3230ms 67040ms
RunMySqlLoaderTask (关闭索引) 1785ms 1367ms 12456ms

最后

以上的测试仅供参考,上面的简单测试一下,数据量大的时候 MySqlLoaderTask 优势是明显的,对于小于 1w 数据量的可以采用多线程批量插入效果更好。有兴趣的小伙伴的可以自己下载代码玩玩。如有更好的
方案,不吝赐教。

  • MySqlLoader 导入 null 数据使用 NULL,而不是mysql文档上说的 \N

百万级数据迁移方案测评小记
免责声明:非本网注明原创的信息,皆为程序自动获取互联网,目的在于传递更多信息,并不代表本网赞同其观点和对其真实性负责;如此页面有侵犯到您的权益,请给站长发送邮件,并提供相关证明(版权证明、身份证正反面、侵权链接),站长将在收到邮件12小时内删除。

全栈的自我修养: 001环境搭建 (使用Vue,Spring Boot,Flask,Django 完成Vue前后端分离开发)

Sts 授权直传阿里云 OSS-.net core实现

96年/离职8个月/拒绝华为offer/目前自由职业-记这大半年来的挣扎与迷茫

前言

磁盘怎么又满了?赶紧 快 打电话给运维扩容扩容扩容!这个问题已经是我入职新公司两个月来,第 3 次听到了。经过一通了解,事情原来是这样的。虽然我们使用了阿里云的 OSS 对象存储服务,但是为了不暴露 AccessKeyId 以及 AccessKeySecret 给客户端,所以全部是由客户端上传到我们的服务器,由我们服务器中转上传,其实只要上传完成删除相应的文件应该就不会引发磁盘空间不足的问题,奈何之前的精神小伙并没有干这一步,文件放磁盘上当备份用。由此引发思考中转上传是不是太麻烦了,直传 OSS 不香吗? 如何保证 AccessKeyId 以及 AccessKeySecret 的安全以及 Bucket 权限问题呢?这就是下面要讲的阿里云 OSS 上的 Sts 授权模式。

STS 临时授权访问 OSS

OSS 可以通过阿里云 STS(Security Token Service)进行临时授权访问。通过 STS,您可以为第三方应用或子用户(即用户身份由您自己管理的用户)颁发一个自定义时效和权限的访问凭证。

以上是官方原话,经过我的实践结合理论,可以得出:我们可以通过 STS 颁发一个临时的 AccessKeyId,AccessKeySecret,SecurityToken, 用户可以通过这3个访问凭证对 Oss 进行相应操作。在我们申请颁布访问凭证的时候,还可以设置对应的权限。

运维角度处理跨域问题

Coding

在使用下面测试前,请先完成 STS临时授权访问OSS 的配置

  • 安装 Nuget
dotnet add package aliyun-net-sdk-core
dotnet add package aliyun-net-sdk-sts
dotnet add package Aliyun.OSS.SDK.NetCore
  • 代码参考案例
class Program
    {
        static void Main(string[] args)
        {
            var bucketName = "<your bucket>";
            var accessKeyId = "<your accessKeyId>";
            var accessKeySecret = "<your accessKeySecret>";
            var endpoint = "<your endpint>";
            var region = "<your region>";
            var roleArn = "<your roleArn>"; // 通过阿里云RAM管理角色管理可以拿到
            var roleSessionName = "xxx"; // 随机指定一个即可
            var objectName = "test.txt";

            IClientProfile profile =
                DefaultProfile.GetProfile(region, accessKeyId, accessKeySecret);
            DefaultAcsClient client = new DefaultAcsClient(profile);
            AssumeRoleRequest request = new AssumeRoleRequest();
            request.AcceptFormat = FormatType.JSON;
            //指定角色ARN
            request.RoleArn = roleArn;
            request.RoleSessionName = roleSessionName;
            request.DurationSeconds = 3600;
            request.Policy = BuildPolicy(bucketName, "avatars"); // 配置对应的权限

            AssumeRoleResponse response = client.GetAcsResponse(request);
            Console.WriteLine("AccessKeyId: " + response.Credentials.AccessKeyId);
            Console.WriteLine("AccessKeySecret: " + response.Credentials.AccessKeySecret);
            Console.WriteLine("SecurityToken: " + response.Credentials.SecurityToken);
            Console.WriteLine("Expiration: " + DateTime.Parse(response.Credentials.Expiration).ToLocalTime());


            var ossClient = new OssClient(endpoint, response.Credentials.AccessKeyId,
                response.Credentials.AccessKeySecret,
                response.Credentials.SecurityToken);

            try
            {
                byte[] binaryData = Encoding.ASCII.GetBytes("test");
                MemoryStream requestContent = new MemoryStream(binaryData);
                // 上传文件。
                ossClient.PutObject(bucketName, $"{bucketName}/{objectName}", requestContent);
                Console.WriteLine("Put object succeeded");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Put object failed, {0}", ex.Message);
            }
        }

        public static string BuildPolicy(string bucket, string dir)
        {
            return "{\n" +
                   "    \"Version\": \"1\", \n" +
                   "    \"Statement\": [\n" +
                   "        {\n" +
                   "            \"Action\": [\n" +
                   "                \"oss:PutObject\"\n" +
                   "            ], \n" +
                   "            \"Resource\": [\n" +
                   $"                \"acs:oss:*:*:{bucket}/{dir}/*\" \n" +
                   "            ], \n" +
                   "            \"Effect\": \"Allow\"\n" +
                   "        }\n" +
                   "    ]\n" +
                   "}";
        }
    }

可以修改 BuildPolicy 里面的 Json 动态配置,以上配置了客户端拿到访问凭据后,只能上传文件到指定目录,没有其他权限了。其次访问STS服务拿到的 AccessKeyIdAccessKeySecret 都是临时与我们阿里云RAM控制面板拿到的是不一样的。这样就无须担心我们 AccessKeyIdAccessKeySecret 泄露以及访问权限的问题。

End

服务端颁发授权凭证,客户端直传 OSS 应该是目前的最佳实践,后面再配合回调地址,可以更好的贴近实际场景。但是回调地址必须是公网可访问的,这里就没整了。直传 OSS 比之前中转节省时间,也不需要占用额外的服务器资源。

Sts 授权直传阿里云 OSS-.net core实现
免责声明:非本网注明原创的信息,皆为程序自动获取互联网,目的在于传递更多信息,并不代表本网赞同其观点和对其真实性负责;如此页面有侵犯到您的权益,请给站长发送邮件,并提供相关证明(版权证明、身份证正反面、侵权链接),站长将在收到邮件12小时内删除。

聊聊Django应用的部署和性能的那些事儿

.NetCore 配合 Gitlab CI&CD 实践 – 开篇

深入学习JDK源码系列之、ArrayList

引言

这是一个系列的文章,讲述的是一个中小型开发团队如何从零开始使用搭建基建 GitLab 代码托管平台,以及使用 GitLab Runner 实现 CI/CD 的故事。本系列通过部署一个完整的 .net core 项目来做配合实战,可能这个案例并不能适合每个人,但希望可以给刚接触 GitLab 以及 CI/CD 的小伙伴带来一些启发。对 GitLab 以及 CI/CD 有一定了解的,可以略过本文,直接开启下一章。

Gitlab CI&CD 是什么?

如上官方图示,可以理解为 Gitlab 给开发者提供了一项功能,在代码提交后自动触发一段开发者自定义的脚本,以此来完成诸如但不限于构建部署的工作。完成一次项目发布我们通常需要以下 4 个步骤:

  • 编译
  • 测试
  • 构建
  • 部署

编译

在编译阶段我们是运行 dotnet build 进行包还原以及项目编译,这里还可以包含团队的代码风格检查

测试

测试阶段主要跑我们自己写的单元测试,题外话:测试也挺难写的

构建

将我们测试通过的项目打包成 docker 镜像,上传到镜像仓库

部署

从镜像仓库上拉取我们镜像,部署到集群上,这里后面我们使用 docker-compose 部署

准备工作

我们这里需要做的事情串起来就是,代码提交到 gitlab,触发平台的 CI/CD 任务,开始编译代码,运行测试,打包镜像并上传镜像,最后部署应用。

安装 GitLab

version: "3"
services:
  gitlab:
    image: gitlab/gitlab-ce:13.1.2-ce.0
    container_name: 'devops-gitlab'
    restart: always
    hostname: '<your hostname>'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url "<your gitlab url>"
        gitlab_rails['gitlab_shell_ssh_port'] = 23
        gitlab_rails['time_zone'] = 'Asia/Shanghai'
        gitlab_rails['smtp_enable'] = true
        gitlab_rails['smtp_address'] = "smtp.exmail.qq.com"
        gitlab_rails['smtp_port'] = 465
        gitlab_rails['smtp_user_name'] = "<your qq email>"
        gitlab_rails['smtp_password'] = "xCcqh*L4jkqFCS"
        gitlab_rails['smtp_authentication'] = "login"
        gitlab_rails['smtp_enable_starttls_auto'] = true
        gitlab_rails['smtp_tls'] = true
        gitlab_rails['gitlab_email_from'] = '<your qq email>'
        gitlab_rails['smtp_domain'] = "exmail.qq.com"
    ports:
      - '81:80'
      - '443:443'
      - '23:22'
    volumes:
      - '/gitlab/config:/etc/gitlab'
      - '/gitlab/logs:/var/log/gitlab'
      - '/gitlab/data:/var/opt/gitlab'
    logging:
      driver: "json-file"
      options:
        max-size: "20m"
        max-file: "10"

我这边使用 docker-compose 来安装的,替换掉上面的对应的 域名地址 以及 邮箱即可使用。我这里用的是 QQ 企业邮箱你也可以换成其他的。随后在配置一下 nginx, 可以通过 80 端口访问 gitlab。

RxJS 中的观察者和迭代器模式

upstream  gitlab{
    # 域名对应 gitlab配置中的 external_url
    # 端口对应 gitlab 配置中的 nginx['listen_port'],通过环境变量可设置
    server 192.168.1.42:81;
}


server{
    listen 80;
    
    # 此域名是提供给最终用户的访问地址
    server_name <your gitlab host name>;

    location / {
        # 这个大小的设置非常重要,如果 git 版本库里面有大文件,设置的太小,文件push 会失败,根据情况调整
        client_max_body_size 50m;

        proxy_redirect off;
        #以下确保 gitlab中项目的 url 是域名而不是 http://git,不可缺少
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        # 反向代理到 gitlab 内置的 nginx
        proxy_pass http://gitlab;
        index index.html index.htm;
    }
}

安装 GitLab Runner

 # For Debian/Ubuntu/Mint
 curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash

 # For RHEL/CentOS/Fedora
 curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash
  • 注册 runner

首先要先获取gitlab-ci的Token:

项目主页 -> Sttings -> CI/CD -> Runners Expand

使用命令注册 gitlab-runner:

gitlab-runner register

需要按照步骤输入:

  • 输入 gitlab 的服务URL,就是你 gitlab 的访问地址
  • 输入 gitlab-ci 的Toekn,获取方式参考上图
  • 关于集成服务中对于这个 runner 的描述
  • 给这个 gitlab-runner 输入一个标记,这个 tag 非常重要,在后续的使用过程中需要使用这个 tag 来指定 gitlab-runner
  • 是否运行在没有 tag 的 build 上面。在配置 gitlab-ci 的时候,会有很多 job,每个job可以通过tags属性来选择runner。这里为true表示如果job没有配置tags,也执行
  • 是否锁定 runner 到当前项目
  • 选择执行器,gitlab-runner 实现了很多执行器,可用在不同场景中运行构建,详情可见 GitLab Runner Executors,这里选用 Shell 模式

重复执行两次,分别选择 shell 模式以及 docker 模式

刷新页面就可以看到新增的一个Runner:

  • 开通阿里云 docker 镜像仓库

这个上阿里云开通一下还是简单的,就不细讲了

结束

好了,到这里准备工作差不多了,下一篇开始实战。

.NetCore 配合 Gitlab CI&CD 实践 – 开篇
免责声明:非本网注明原创的信息,皆为程序自动获取互联网,目的在于传递更多信息,并不代表本网赞同其观点和对其真实性负责;如此页面有侵犯到您的权益,请给站长发送邮件,并提供相关证明(版权证明、身份证正反面、侵权链接),站长将在收到邮件12小时内删除。

Pytorch_第六篇_深度学习 (DeepLearning) 基础 [2]—神经网络常用的损失函数

.NetCore 配合 Gitlab CI&CD 实践 – 单体项目

一个可屏蔽长短链接的网络模块

前言

上一篇博文 .NetCore 配合 Gitlab CI&CD 实践 – 开篇,主要简单的介绍了一下 GitLab CI 的持续集成以及持续部署,这篇将通过 GitLab CI 发布一个 .net core 项目,来带小伙伴们感受一下自动化的魅力,从此告别手动发布。

准备工作

创建一个空MVC项目来进行演示:

mkdir hello-world
cd hello-world
dotnet new sln -n HelloWorld
mkdir src
cd src
dotnet new mvc -n GitLabCIDemo
cd ../
dotnet sln add .\src\GitLabCIDemo\GitLabCIDemo.csproj

完成以上创建后,用 vscode 打开应该是下面这个样子:

项目上传至 GitLab

在 gitlab 上新建一个 hello-world 的项目,将本地的项目上传。这个按照如下提示操作即可:

项目上传成功后,切一个 dev 分支出来,我这里的策略是,代码提交到 dev 分支是自动发布到开发环境进行验证的,生产环境是通过 master 分支打 tag 进行发布的。

  • 切换到 dev 分支!
  • 切换到 dev 分支!
  • 切换到 dev 分支!

添加相关脚本

hello-world 文件夹内创建 .build/docker 文件夹,并添加如下脚本以及Dockerfile:

  • build-image.sh
docker build -f .build/docker/Dockerfile --build-arg PROJECT=$1 --build-arg ASPNETCORE_ENVIRONMENT=$2 -t $3 .
  • build-project.sh
set -e
for arg in "$@"
do
    target=$(pwd)/src/$arg
    dotnet restore -v n $target
    dotnet publish -c Release -o $target/publish $target
done
  • push-image.sh
NEW_TAG="registry.cn-hangzhou.aliyuncs.com/xxx/$1"; // 这里得用你自己命名空间哦
docker tag $1 $NEW_TAG
docker push $NEW_TAG
docker rmi $NEW_TAG
  • Dockerfile
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-alpine
ARG PROJECT
ARG ASPNETCORE_ENVIRONMENT
ENV ASPNETCORE_ENVIRONMENT ${ASPNETCORE_ENVIRONMENT}
WORKDIR /app
COPY src/${PROJECT}/publish .
RUN echo "#!/bin/bash \n dotnet ${PROJECT}.dll" > start.sh && chmod +x ./start.sh
ENTRYPOINT ["./start.sh"]

这里构建镜像所使用 3.1-alpine 构建出来的镜像体积只有其他镜像版本构建出来体积的一半。推荐使用。到此目录结构就成了现在这样:

至此准备工作已经差不多了!我们先简单过一下 CI 的流程:

提交代码 –> 编译 –> 测试 –> 构建镜像 –> 发布

编译 — Build

hello-world 目录下添加 .gitlab-ci.yml 文件,添加 build 任务:

stages:
  - build

helloworld-build:
  stage: build
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - .build/docker/build-project.sh GitLabCIDemo
  artifacts:
    paths:
      - src/*/bin
      - src/*/publish

这里起一个容器来跑编译任务,具体细节可以看 build-project.sh 脚本,用 artifacts 将发布出来的资源上传,给后面的 构建任务使用,不需要重复 build,节约时间。这里执行会出现如下错误:

/bin/bash: line 89: .build/docker/build-project.sh: Permission denied

这是因为脚本没有执行权限,通过 chmod 命令可以解决:

chmod +x build-image.sh build-project.sh push-image.sh

重新提交,触发 build 任务。打开 GitLab CI 界面,执行成功,是不是很开心呢?

测试 — Test

现在项目里面没有测试代码,那就新建一个吧。在 hello-world 根目录下:

mkdir test
cd test
dotnet new xunit -n GitLabCIDemo.UnitTests

更新 .gitlab-ci.yml 添加 Test 任务:

stages:
  - build
  - test

helloworld-build:
  stage: build
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - .build/docker/build-project.sh GitLabCIDemo
  artifacts:
    paths:
      - src/*/bin
      - src/*/publish

helloworld-test:
  stage: test
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - dotnet test -c Release
  dependencies:
    - helloworld-build

等待一会,查看 CI 运行。

算法学习笔记:连通图详解

构建 Docker 镜像 — Pack

我这里使用的是阿里云的镜像仓库,需要现在阿里云上创建对应的命名空间以及镜像名称。我这里给镜像名取名为 hello-world,别忘了修改 push-image.sh 中的命名空间哦!

更新 .gitlab-ci.yml 添加 Pack 任务:

stages:
  - build
  - test
  - pack

helloworld-build:
  stage: build
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - .build/docker/build-project.sh GitLabCIDemo
  artifacts:
    paths:
      - src/*/bin
      - src/*/publish

helloworld-test:
  stage: test
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - dotnet test -c Release
  dependencies:
    - helloworld-build

helloworld-pack-staging:
  stage: pack
  tags:
    - shell
  script:
    - .build/docker/build-image.sh GitLabCIDemo Staging hello-world:beta
    - .build/docker/push-image.sh hello-world:beta
  dependencies:
    - helloworld-build
  only:
    - dev
  • Staging: 用来设置环境变量 ASPNETCORE_ENVIRONMENT,让 .net core 读取对应的配置文件,可以设置Development,Staging,Production 三种,可以在对应的环境设置对应环境变量,使用不同配置。

  • beta: 因为是开发环境,就一直使用同一个 tag 去覆盖之前的镜像,每次 pull 最新的镜像就好了,也可以使用 $CI_COMMIT_SHORT_SHA 使用当前 git 提交的 hash 值作为版本号

CI 应该执行的差不多,再去瞧瞧呗! 又是全绿,真是开心!额,全绿,怪怪的…

打开阿里云镜像容器服务,查看一下刚刚上传的容器镜像吧!

部署 — Deploy

这里我图方便就使用 docker-compose 来做演示了,通常部署环境都是使用集群来部署的,当然单机部署也不是不无可能的,我内网用 k3s 搭建的一个集群,为啥不用 k8s,因为要求资源配置比较高,k3s 刚好够用。但是部署到 k3s 需要写挺多的配置的文件,可以单独写一篇博文介绍。

作为自动化最后一步,无论你是用 k8s,k3s,docker swarm……,都是拉取对应的镜像,进行部署。思路是一样的,只是部署方式略有不同。这里通过 docker-compose 来发布 hello-world 应用咯。

在部署的 Linux 服务器上创建文件夹 /deploy ,在目录下添加 docker-compose.yml 文件,添加如下内容:

version: "3.8"
services:
  hello-world:
    image: registry.cn-hangzhou.aliyuncs.com/jd-rd/hello-world:beta
    container_name: hello-world
    restart: always
    ports: 
      - 5013:80
    networks:
      - basic_service  

networks:
  basic_service:

更新 .gitlab-ci.yml,添加部署任务:

stages:
  - build
  - test
  - pack
  - deploy

helloworld-build:
  stage: build
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - .build/docker/build-project.sh GitLabCIDemo
  artifacts:
    paths:
      - src/*/bin
      - src/*/publish

helloworld-test:
  stage: test
  tags:
    - docker
  image: mcr.microsoft.com/dotnet/core/sdk:3.1
  script:
    - dotnet test -c Release
  dependencies:
    - helloworld-build

helloworld-pack-staging:
  stage: pack
  tags:
    - shell
  script:
    - .build/docker/build-image.sh GitLabCIDemo Staging hello-world:beta
    - .build/docker/push-image.sh hello-world:beta
  dependencies:
    - helloworld-build
  only:
    - dev

deploy-staging:
  stage: deploy
  tags:
    - staging
  script:
    - cd /deploy && docker-compose pull && docker-compose up --force-recreate -d && docker ps
  only:
    - dev

等待整个CI跑完,查看 CI 运行结果

通过服务器IP + 5013 访问应用了,就可以看到服务更新

修改一下 Index.cshtmlWelcome 修改为 Hello Devops ! ,重新提交一下,稍等片刻,重新访问即可看到变化了。

至此一个简单的 CI 流程已经走完了,各位看官可以根据自己的需求,继续探索。

题外话

如果将脚本都放在项目里面的话,将来涉及到脚本变更,需要每个项目都给改过去,这是十分痛苦的事情。这里推荐小伙伴可以通过 git submodule 子模块的方式进行引用,将公共的脚本都给提取出来,项目通过子模块来加载脚本项目,将来脚本变更,每个项目只需要更新一下子模块就好。

总结

通过以上一个小案例已经带小伙伴了解了一圈 GitLab-CI 如何来发布一个 .net core 应用,感受了一下 GitLab-ci 的魅力。但是以上方案还是有瑕疵的,对于单体应用来说,没有太大问题,但并不适合微服务项目。在微服务项目中,如果多个服务散落在多个仓库中,需要多个项目代码改动其实是很不方便的,所以现在很多的微服务项目都采用 Mono 仓库风格及将所有的服务都放在一个仓库里面,仓库体积虽然大,但是改动起来更方便。本篇就先到这里了,有关于 GitLab-CI 对于 Mono 仓库风格项目 CI&CD 探索实践,且听下回分解。

.NetCore 配合 Gitlab CI&CD 实践 – 单体项目
免责声明:非本网注明原创的信息,皆为程序自动获取互联网,目的在于传递更多信息,并不代表本网赞同其观点和对其真实性负责;如此页面有侵犯到您的权益,请给站长发送邮件,并提供相关证明(版权证明、身份证正反面、侵权链接),站长将在收到邮件12小时内删除。

《算法笔记》10. 并查集、图相关算法、看完这篇不能再说不会了。