Demo

文章头部frot-matter编写参考 所有样式来源于:https://xaoxuu.com/wiki/volantis/tag-plugins/ issue标签参考 相册一行一图 一行多图 多行多图 githu...
demo

(LeetCode系列)刷题记

排序算法总结

基础排序算法

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package basic_sort

/**
* @Author: yirufeng
* @Date: 2021/4/13 8:28 下午
* @Desc: 选择排序

时间复杂度:假设数组中有n个数字
大循环需要遍历n-2趟,然后每一个大循环中,
我们都需要从开始的数字一直到最后选出最小的数字(时间复杂度:O(n)),然后填充到当期那还没有排好序的起始位置

最后总的时间复杂度:O(n^2),
空间复杂度:O(1)。
稳定的排序算法(因为两个相等的数字前面那个一定是排序的时候第一个会被放置到前面的)
**/

func SelectedSort(nums []int) {
selectedSort(nums)
}

func selectedSort(nums []int) {
var min int
for i := 0; i < len(nums)-1; i++ {
//每次从nums[i]开始起
min = i
//依次与后面比对来选择最小的
for j := i + 1; j < len(nums); j++ {
if nums[min] > nums[j] {
min = j
}
}
//交换nums[min]与nums[i]
nums[i], nums[min] = nums[min], nums[i]
}
}

选择排序

选择排序总结:

  1. 时间复杂度:O(n^2)
  2. 空间复杂度:O(1)。
  3. 不稳定的排序算法(比如A 80 B 80 C 70 这三个卷子从小到大排序,最后将会变成CBA,但是稳定的应该是CAB)

三个版本的冒泡排序:

  1. 最基本的
  2. 如果某次冒泡的时候没有交换元素,那么说明这一趟以及后面的元素都是有序的,之后后面我们就不再需要进行冒泡,可以直接退出
  3. 在第二种改进的基础上再使用一个变量,表示我们最后交换的位置,下次遍历到这个位置就可以了

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package basic_sort

/**
* @Author: yirufeng
* @Date: 2021/4/13 8:28 下午
* @Desc:

有好几个版本:
1. 最基本的
2. 如果某次冒泡的时候没有交换元素,那么说明这一趟以及后面的元素都是有序的,之后后面我们就不再需要进行冒泡,可以直接退出
3. 在第二种改进的基础上再使用一个变量,表示我们最后交换的位置,下次遍历到这个位置就可以了
**/

func BubbleSort(nums []int) {
bubbleSortV2(nums)
}

//最基本的
func bubbleSortV1(nums []int) {
for i := 1; i < len(nums); i++ { //冒泡的次数
for j := 0; j < len(nums)-i; j++ {
//如果前面比后面大就交换
if nums[j] > nums[j+1] {
nums[j], nums[j+1] = nums[j+1], nums[j]
}
}
}
}

//如果某次冒泡的时候没有交换元素,那么说明这一趟以及后面的元素都是有序的,之后后面我们就不再需要进行冒泡,可以直接退出
func bubbleSortV2(nums []int) {
//表示某一趟是否有元素交换
flag := true
for i := 1; i < len(nums); i++ { //冒泡的次数
flag = true
for j := 0; j < len(nums)-i; j++ {

//如果前面比后面大就交换
if nums[j] > nums[j+1] {
flag, nums[j], nums[j+1] = false, nums[j+1], nums[j]
}
}
//如果没有元素交换,说明已经有序,直接退出即可
if flag {
break
}
}
}

//在第二种改进的基础上再使用一个变量,表示我们最后交换的位置,下次遍历到这个位置就可以了
//使用一个变量记录最后发生交换的位置,说明该位置之后都是有序的
func bubbleSortV3(nums []int) {
//表示某一趟是否有元素交换
flag := true
//表示最后发生交换的位置
//注意点1:这里必须再额外使用临时变量,因为如果只是用一个变量lastSwapPos的话,
//lastSwapPos的值会一直改变,因此如果一旦变小,我们的for循环就会推出
lastSwapPos := len(nums) - 1 //注意点2:初始值赋值是len(nums) - 1
for i := 1; i < len(nums); i++ { //冒泡的次数
lastSwapPosTemp := len(nums) - i //注意点3:初始值赋值是len(nums) - i
flag = true
//下次遍历的时候遍历到我们上次最后发生交换的位置就可以了
for j := 0; j < lastSwapPos; j++ {
//如果前面比后面大就交换
if nums[j] > nums[j+1] {
flag, nums[j], nums[j+1], lastSwapPosTemp = false, nums[j+1], nums[j], j //注意点4:这里lastSwapPosTemp应该赋值j,因为j与j+1比较过了,所以就认为j之后是已经有序的了
}
}
//如果没有元素交换,说明已经有序,直接退出即可
if flag {
break
}

lastSwapPos = lastSwapPosTemp
}
}

冒泡排序

冒泡排序总结:

  1. 时间复杂度:O(n^2),最好是O(n)
  2. 空间复杂度:O(1)。
  3. 稳定

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package basic_sort

/**
* @Author: yirufeng
* @Date: 2021/4/13 8:28 下午
* @Desc:

时间复杂度:O(n^2)
空间复杂度:O(1)
稳定的:因为是到前面找到一个小于等于自己的后面那个位置
**/

func InsertSort(nums []int) {
insertSort(nums)
}

func insertSort(nums []int) {
var j int
//第一个元素已经有序,只需要插入后面的元素即可
for i := 1; i < len(nums); i++ {
//当前要插入的元素目前位于i位置
cur := nums[i]
//从后往前找,直到前面元素小于当前元素就停,并且遍历的过程中不断将前面的元素移动到后面
for j = i - 1; j >= 0 && nums[j] > cur; j-- {
nums[j+1] = nums[j]
}
//此时j指向的元素就是前面那个小于或者等于当前元素的位置
//但是我们应该在j+1位置插入
nums[j+1] = cur
}
}

直接插入排序总结

直接插入排序总结:

  1. 时间复杂度:O(n^2),
  2. 空间复杂度:O(1)。
  3. 稳定的:因为是到前面找到一个小于等于自己的后面那个位置

进阶排序算法

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package advanced_sort

import (
"algos/模板/排序/util"
"fmt"
"sort"
)

/**
* @Author: yirufeng
* @Date: 2021/4/14 3:31 下午
* @Desc: 归并排序
**/

func MergeSort(nums []int) {
mergeSort(nums, 0, len(nums)-1)
}

func mergeSort(nums []int, l, r int) {
if l == r {
return
}

//找到中间点,一分为二
mid := l + (r-l)>>1
//划分成左右两个有序的空间
mergeSort(nums, l, mid)
mergeSort(nums, mid+1, r)
//将左右两部分以mid为划分轴进行合并
merge(nums, l, mid, r)

}

//合并nums[l:mid+1] 与 nums[mid+1:r+1]两部分内容
func merge(nums []int, l, mid, r int) {
i, j := l, mid+1
cur := 0
//注意点1:这里必须借助一个数组,否则我们前面可能还没有被排序的结果会被我们后半部分的内容覆盖掉,导致前面就没有内容
help := make([]int, r-l+1)
for i <= mid && j <= r {
if nums[i] < nums[j] {
help[cur], cur, i = nums[i], cur+1, i+1
} else {
help[cur], cur, j = nums[j], cur+1, j+1
}
}

for i <= mid {
help[cur], cur, i = nums[i], cur+1, i+1
}
for j <= r {
help[cur], cur, j = nums[j], cur+1, j+1
}

//最后记得我们的help数组中的内容要放回到我们的原来的数组中
for i := 0; i < len(help); i++ {
nums[l+i] = help[i]
}
}

func main() {
nums := util.GenerateRandomNums(0, 100, 30)
fmt.Println(nums)
temp := make([]int, 30)
copy(temp, nums)
sort.Ints(temp)
MergeSort(nums)
fmt.Println(temp)
fmt.Println(nums)
}

归并排序

  1. 时间复杂度:O(nlogN) 最好最坏都是O(NlogN)
  2. 空间复杂度:O(n)。需要一个辅助空间
  3. 是否稳定:稳定的(因为一旦两个数相等我们就不比较,并且每次都是前半部分与后半部分进行比较,所以前面同样的内容与后面同样的内容的相对位置不会改变)

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package main

import (
"algos/模板/排序/util"
"fmt"
"log"
"sort"
)

/**
* @Author: yirufeng
* @Date: 2021/4/14 3:29 下午
* @Desc: 从小到大的堆排序(需要建立一个大顶堆)

从小到大排序需要建立一个大顶堆,因为我们建立好大顶堆之后,每次从堆头开始排除元素,然后都会将堆头放到目前数组的最后位置,最后位置会不断缩小,
因此我们最后的位置就是一个不断往前移动的过程,从而就是说我们得到的整个数组是从小到大的
**/

func HeapSort(nums []int) {
heapSort(nums)
}

func heapSort(nums []int) {
if nums == nil || len(nums) < 2 {
return
}

for i := 0; i < len(nums); i++ {
heapPush(nums, i)
}

log.Println("建堆完成--------------->", nums)
heapSize := len(nums)

//之后不断吐出元素
for heapSize > 0 {
nums[0], nums[heapSize-1] = nums[heapSize-1], nums[0]
heapSize--
heapify(nums, heapSize)
}
}

//表示当前要加入的是nums中的索引为index的元素
func heapPush(nums []int, index int) {
for (index-1)>>1 >= 0 && nums[index] > nums[(index-1)>>1] {
nums[index], nums[(index-1)>>1], index = nums[(index-1)>>1], nums[index], (index-1)>>1
}
}

//length 表示堆的元素个数
func heapify(nums []int, length int) {
index := 0
// (index << 1 + 1) < length 说明是有左子树的
for (index<<1 + 1) < length { //思路:每次找到左右孩子中更大的与父进行交换
left := index<<1 + 1
//如果有右子树并且右子树比左子树大
if left+1 < length && nums[left+1] > nums[left] {
left++
}
//如果当前节点比左右孩子中大的大,就不交换
if nums[left] <= nums[index] {
break
}
//如果当前节点比左右孩子中大的小,交换当前节点与左右孩子中较大的
//同时让index变为left
nums[left], nums[index], index = nums[index], nums[left], left
}
}

func main() {
nums := util.GenerateRandomNums(0, 100, 50)
temp := make([]int, 50)
copy(temp, nums)
sort.Ints(temp)
fmt.Println(temp)
HeapSort(nums)
fmt.Println(nums)
}

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package main

import (
"algos/模板/排序/util"
"fmt"
"sort"
)

/**
* @Author: yirufeng
* @Date: 2021/4/15 2:20 下午
* @Desc: 从大到小的排序,需要建立一个小顶堆
**/

func HeapSort(nums []int) {
heapSort(nums)
}

func heapSort(nums []int) {

//如果nums为空或者元素个数小于两个,可以直接退出
if nums == nil || len(nums) < 2 {
return
}

//此时我们需要不断将元素加入我们的堆中
for i := 1; i < len(nums); i++ {
heapInsert(nums, i)
}

//获取堆的大小
heapSize := len(nums)

//此时我们不断将堆里面的元素弹出放到应该放置的位置
for heapSize > 0 {
//将堆的最后一个元素与堆顶交换
nums[0], nums[heapSize-1] = nums[heapSize-1], nums[0]
//堆的元素个数减去1
heapSize--
//开始从堆顶从上往下开始调整堆
heapAdjustFromTopToBottom(nums, heapSize-1) // 从下到上的堆调整
}
}

//第二个参数表示插入的元素位于nums的位置
func heapInsert(nums []int, index int) {
//不断比较当前插入的位置的元素与父节点的大小,如果比父节点小就交换
for (index-1)>>1 >= 0 && nums[(index-1)>>1] > nums[index] {
nums[index], nums[(index-1)>>1], index = nums[(index-1)>>1], nums[index], (index-1)>>1
}
}

//第二个参数表示当前堆的元素个数
func heapAdjustFromTopToBottom(nums []int, length int) {
index := 0
for index<<1+1 < length {
left := index<<1 + 1

//如果有右孩子并且右比左小
if left+1 < length && nums[left+1] < nums[left] {
left++
}

//当前节点小于等于两个孩子较小的
if nums[index] <= nums[left] {
break
}
nums[index], nums[left], index = nums[left], nums[index], left
}
}

func main() {
nums := util.GenerateRandomNums(0, 100, 50)
temp := make([]int, 50)
copy(temp, nums)
sort.Ints(temp)
fmt.Println(temp)
HeapSort(nums)
fmt.Println(nums)
}

点击查看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package main

import (
"algos/模板/排序/util"
"fmt"
"math/rand"
"sort"
)

/**
* @Author: yirufeng
* @Date: 2021/4/14 3:31 下午
* @Desc: 从小到大的快速排序
**/

func QuickSort(nums []int) {
quickSort(nums, 0, len(nums)-1)
}

//表示对[l,r]的元素进行快排
func quickSort(nums []int, l, r int) {
if l < r {
//在[l,r]区间内生成一个随机数作为划分
index := rand.Intn(r-l+1) + l
//每次都把我们随机选择的元素交换到最后
nums[index], nums[r] = nums[r], nums[index]
//进行划分,得到两个相等的区间
less, more := partition(nums, l, r)
//继续对小于和大于的两个区间进行快速排序
quickSort(nums, l, less-1)
quickSort(nums, more+1, r)
}
}

//返回两个结果是等于我们随机数的区间的左端点和右端点
func partition(nums []int, l, r int) (int, int) { //使用nums[r]作为一个划分
less, more := l-1, r
num := nums[r]
cur := l
for cur < more {
if nums[cur] < num {
nums[less+1], nums[cur], less, cur = nums[cur], nums[less+1], less+1, cur+1
} else if nums[cur] > num {
nums[more-1], nums[cur], more = nums[less+1], nums[more-1], more-1
} else if nums[cur] == num {
more++
}
}
nums[more], nums[r] = nums[r], nums[more]
//每次随机择一个划分点
return less + 1, more - 1
}

func main() {
nums := util.GenerateRandomNums(0, 100, 10)
fmt.Println(nums)
temp := make([]int, 10)
copy(temp, nums)
sort.Ints(temp)
fmt.Println(temp)
QuickSort(nums)
fmt.Println(nums)
}

快速排序

思路:采用荷兰国旗的问题进行划分,每次可以划分为3个区间,分别是小于,等于以及大于的区间。

  1. 时间复杂度:O(nlogN) 最好是O(nlogN) 最坏是O(n^2)
  2. 空间复杂度:O(n)。
  3. 是否稳定:不稳定

!!!

饶大文章汇总

饶大文章汇总

Go语言

深度解密系列

Go语言其他

汇总

配置编程环境Linux服务器

前提:将所有软件包放到~目录下

安装Git

操作存放在~目录下的Git-v2.26.2.tar.gz文件

解压并安装

1
2
3
4
5
6
7
8
9
tar -zxvf Git-v2.26.2.tar.gz
yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel gcc-c++ perl-ExtUtils-MakeMaker
cd git-2.26.2/
yum -y install autoconf
make configure
./configure --prefix=/usr/local/git
make profix=/usr/local/git
make install
yum remove git

之后加入环境变量

  1. 编辑配置⽂件:vim /etc/profile
  2. 尾部加⼊Git的bin路径配置即可:
    • export GIT_HOME=/usr/local/git
    • export PATH=$PATH:$GIT_HOME/bin
  3. 执行source /etc/profile使环境变量⽣效即可。

安装JDK

操作存放在~目录下的jdk-8u161-linux-x64.tar.gz

卸载系统自带的openJDK

  1. rpm -qa | grep java
  2. yum -y remove 我们上一步执行的结果

开始安装我们自己的jdk

  1. cd /usr/local/
  2. mkdir java
  3. cd java
  4. tar -zxvf /root/jdk-8u161-linux-x64.tar.gz -C ./
  5. 编辑/etc/profile⽂件,在⽂件尾部加⼊如下JDK环境配置即可:
    1
    2
    3
    4
    JAVA_HOME=/usr/local/java/jdk1.8.0_161 
    CLASSPATH=$JAVA_HOME/lib/
    PATH=$PATH:$JAVA_HOME/bin
    export PATH JAVA_HOME CLASSPATH
  6. source /etc/profile
  7. 验证安装结果:执行java -versionjavac

安装node

操作存放在~目录下的node-v12.16.3-linux-x64.tar.xz

  1. cd /usr/local/
  2. mkdir node
  3. cd node
  4. tar -xJvf /root/node-v12.16.3-linux-x64.tar.xz -C ./
  5. 编辑/etc/profile⽂件,在⽂件尾部加⼊如下环境配置即可:
    1
    2
    # Nodejs 
    export PATH=/usr/local/node/node-v12.16.3-linux-x64/bin:$PATH
  6. source /etc/profile
  7. 验证安装结果:执行node -vnpm versionnpx -v都输出了版本信息即可。
linux

mysql中的索引

查看代码测试 索引参考参考了解索引(索引概念)索引是一种特殊的文件(InnoDB数据表上的索引是表空间的一个组成部分),它们包含着对数据表里所有记录的引用指针。索引是一种数据结构。数据库索引,是数据库管理系统中一个排序的数据结构,以协助快速查询、更新数据库表中数据。索引的实现通常使用B数及其变种B+数。更通俗的说,索引就相当于目录...

parallel安装的虚拟机登录root

打开terminal

  1. 执行sudo passwd
  2. 出现Password:,键入自己当前用户的密码
  3. 出现Enter new UNIX password:这个是root的密码
  4. 出现Retype new UNIX password:重复root的密码

之后就可以使用su命令以及刚才设置的root用户密码切换到root用户

tools

网易微课堂之中间件学习

分布式消息中间件 查看内容 总览分布式消息中间件设计篇amqamq入门amq支持的消息协议讲解ActiveMQ高可用集群方案持久化原理及事务机制rabbitmqrabbitmq入门以及内部消息分发机制课程目录AMQP协议RabbitMQ简介RabbitMQ基本概念RabbitMQ安装运行RabbitMQ基本配置RabbitMQ管理界...

mysql学习

安装环境 使用虚拟机的docker安装mysql Mysql逻辑架构 如图所示我们知道,Mysql可以分为server和存储引擎两大层。 Server层:涵盖 MySQL 的大多数核心服务功能,以及所有的内置函数(如日期、时间、数学和加密函数等),所有跨存储引擎的功能都在这一层实现,比如存储过程、触发器、视图等。 存储引擎层负责数据的存储和提取。其架构模式是插件式的,支持 InnoDB、...
mysql

centos7安装docker

系统要求:docker支持64位Centos7,并且要求内核版本(查看Linux系统内核版本:uname -r)不低于3.10

卸载旧版本

安装docker

卸载旧版本

旧版本的docker称为docker或docker-engine,使用如下命令卸载旧版本

1
sudo yum remove docker docker-common docker-selinux docker-engine

安装方式一:使用yum安装

1
sudo yum install docker-ce

如果执行之后返回的是没有可用软件包,此时我们需要安装必要的软件依赖以及更新增加docker-ce yum源

1
2
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
执行完这两条命令之后我们便可以重新执行`sudo yum install docker-ce`进行安装

安装方式二:使用脚本安装

在测试或开发环境中docker官方为了简化安装流程,提供了一套便捷的安装脚本,centos系统上可以使用这套脚本进行安装

1
2
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh --mirror Aliyun
执行完这个命令之后,系统会自动将一切工作准备好,并把docker ce的Edge版本安装在系统中
docker

基于Centos7 搭建 gitlab

环境

centos7腾讯云服务器一台

步骤

前提

  1. 更新软件包:yum update -y
  2. 安装 sshd:yum install -y curl policycoreutils-python openssh-server
  3. 启用并启动sshd:systemctl enable sshdsystemctl start sshd
  4. 配置防火墙:
    1. 打开 /etc/sysctl.conf 文件,在文件最后添加新的一行并按 Ctrl + S 保存:net.ipv4.ip_forward = 1
    2. 启用并启动防火墙:systemctl enable firewalldsystemctl start firewalld
    3. 放通 HTTP:firewall-cmd --permanent --add-service=http
    4. 重启防火墙:systemctl reload firewalld
    5. 在实际使用中,可以使用 systemctl status firewalld 命令查看防火墙的状态。
  5. 安装postfix
    1. GitLab 需要使用 postfix 来发送邮件。当然,也可以使用 SMTP 服务器,具体步骤请参考 官方教程
    2. 安装:yum install -y postfix
    3. 打开 /etc/postfix/main.cf 文件,在第 119 行附近找到 inet_protocols = all,将 all 改为 ipv4 并按 Ctrl + S 保存:inet_protocols = ipv4
    4. 启用并启动 postfix:systemctl enable postfix + systemctl start postfix

配置 swap 交换分区

由于 GitLab 较为消耗资源,我们需要先创建交换分区,以降低物理内存的压力。在实际生产环境中,如果服务器配置够高,则不必配置交换分区。

  1. 新建 2 GB 大小的交换分区:dd if=/dev/zero of=/root/swapfile bs=1M count=2048
  2. 格式化为交换分区文件并启用:mkswap /root/swapfileswapon /root/swapfile
  3. 添加自启用。打开 /etc/fstab 文件,在文件最后添加新的一行并按 Ctrl + S 保存:/root/swapfile swap swap defaults 0 0
  4. 将软件源修改为国内源:由于网络环境的原因,将 repo 源修改为清华大学。在 /etc/yum.repos.d 目录下新建 gitlab-ce.repo文件并保存。内容如下:
    1
    2
    3
    4
    5
    [gitlab-ce]
    name=Gitlab CE Repository
    baseurl=https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el$releasever/
    gpgcheck=0
    enabled=1

安装gitlab

  1. 刚才修改过了 yum 源,因此先重新生成缓存:yum makecache

    (此步骤执行时间较长,一般需要 3~5 分钟左右,请耐心等待)

  2. 安装 GitLab::yum install -y gitlab-ce

    (此步骤执行时间较长,一般需要 3~5 分钟左右,请耐心等待)

  3. 配置 GitLab 的域名(非必需):打开 /etc/gitlab/gitlab.rb 文件,在第 13 行附近找到 external_url 'http://gitlab.example.com',将单引号中的内容改为自己的域名(带上协议头,末尾无斜杠),并按 Ctrl + S 保存。例如:external_url 'http://work.myteam.com' 记得将域名通过 A 记录解析到 centos7对应的IP 哦。
  4. 设置完成后使用如下命令重启 GitLab的配置:sudo gitlab-ctl reconfigure + 重启gitlab服务sudo gitlab-ctl restart

    (此步骤执行时间较长,一般需要 5~10 分钟左右,请耐心等待)

  5. 至此,我们已经成功地在 CentOS 7 上搭建了 GitLab。 现在可以在这里(http://centoss7主机ip地址/)访问 GitLab 了。

注意事项

  1. 在实际生产中,建议您使用 2 核 4 GB 或更高配置的 CVM。点击这里 可以查看 GitLab 官方推荐的配置和可承载人数对应表。
  2. 再次提醒您,定期执行 yum update -y 以保持各软件包的最新状态。
CI/CD