凤凰项目真的是一本伟大的书，梳理记录了一位IT运维的传奇故事。
快速通读感想
本书的是主人公比尔•帕尔默，面对一个管理混乱的IT部门，通过借鉴工厂管理方法，在埃瑞克的引导下，发现了IT的“四种工作”以及“三种工作方法”。同时创造性的建立了可视化工作流这一方案。实现了一天十次部署这一不可能完成的任务，最终帮助公司走出了困境。
那么，比尔的困难有哪些呢？我简单的数了一下：
1、部门间的沟通配合存在巨大的鸿沟，没有一条反馈回路。
2、变更没有一个合理的管理方法，没有风险评估、变更记录，变更规划及事件追踪。
3、没有认清楚自己的任务，无数的任务随意的插入进来。
4、工作未标准化，某个人变成了不可提代的角色
5、最关键的一点是，公司对于IT的不重视，甚至决定用外包来取代他们节约资金。

那么针对这些问题，比尔又做了什么呢？
1、明确了每个人的任务：引导自己的同事为每一项任务列出一个清单，描述变更内容，风险，执行时间，并且统一审核。并且追踪每一个任务的进度，将工作进度可视化。
2、指定变更流程，任何未审批的变更一律禁止进行
3、IT部门合理规划任务，保持员工可以专注于一个工作，以提高工作效率（工时规划）。
4、标准化工作

对此，比尔定义了四种工作：
1、业务项目工作
2、内部项目
3、变更
4、计划外工作（技术债带来的反工作）
同时明确了三种工作法
第一工作法：制止工作缺陷交接至下游工作中心，管理工作流，运用约束点来控制节奏，确认那些是重要工作。
第二工作法，建立反馈环路，一直往回通向产品定义，设计，开发的最初环节。
第三工作法：适当的施压，暴露问题，并根据问题将工作流程化，标准化。

此书通过3天共5小时完成第一次通读。
准备第二遍精读，并记录感想。

一、为什么要用docker
大家都知道，传统的VM解决的核心问题是资源分配的问题，那么容器解决的问题是什么呢？是应用开发、测试和部署。
docker是用go语言开发的，基于linux内核的CGroup、Namespace以及AUFS类的UnionFS技术，实现对进程进行封装隔离带轻量级的虚拟化技术之一。通过共享内核，能够把应用需要的运行环境、缓存环境、数据库环境封装起来，实现快速发布，自动运维，自动扩容，微服务等大技术，让小公司玩转大技术不再是梦想。
二、docker的优势

我们可以看一下docker官方宣称的几大作用吧。
1、实现代码端到端的发布流程，无缝的配置到各个测试环境之中，同时也可以迁移到任何环境之中，实现了底层和应用层的解耦。
2、容器级别的虚拟化可以实现资源的最大化应用，避免了系统级的资源浪费。
3、开发环境生产化，实现原生环境，最大限度模拟生产分布式部署的环境。
4、应用进程级的隔离，有利于微服务的解耦。
5、快速部署，秒级的应用启动速度，便于大规模集群的管理。

三、快速部署一个docker环境
1、以centos7环境为例
1.1、鉴于centos7自带的3的内核存在一些bug导致docker运行的不稳定，可升级内核为4.4.X 以上即可
rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
yum –enablerepo=elrepo-kernel install -y kernel-lt
设置开机从新内核启动
grub2-set-default 0
1.2、设置yum源
yum-config-manager –add-repo https://download.docker.com/linux/centos/docker-ce.repo
安装docker
yum install docker-ce
1.3、优化docker
1.3.1、优化docker存储位置
在/etc/docker/deamon.json中添加
“data-root”: “/mnt/docker-lib”
1.3.2、优化国内镜像源
在/etc/docker/deamon.json中添加
“registry-mirrors”: [“https://registry.docker-cn.com"]

四、简单谈论一下docker
1、容器的本质是什么呢？
容器可以简单的看作是CGroup、Namespace、Rootfs的集合。
1.1、Namespace是linux提供的一种内核级别的隔离方法。到目前为止，一共提供了Mount Namespace，UTS Namespace，IPC Namespace，PID Namespace，Network Namespace，User Namespace，其中centos7需要升级到3.8以上的内核才可以使用所有的namespace，不过出于稳定性考虑，建议升级到4.4.X以上的内核。

1.2.1、Cgroup是linux内核提供的一种资源控制的机制。细化的看，Cgroup提供了以下几个功能
a、资源限制，Cgroup会对不同进程使用的资源进行限制，设定使用上限，一旦超过这个限制便会发出警告，比如OOM。
b、优先级管理，Cgroup会对不同的进程分配CPU，IO资源。
c、资源统计，Cgroup可以统计系统的资源使用情况。
e、进程控制，对进程组进行挂起、恢复等操作。
f、进程组隔离，比如：使用ns子系统可以使不同的进程组使用不同的namespace，以达到隔离的目的，不同的进程组有各自的进程、网络、文件系统挂载空间。
所以从本质上来看，cgroup是内核附加在程序山的一系列钩子(hook)，通过事件触发钩子以达到对资源的限制和追踪。
1.3、Rootfs是容器启动时内部的文件系统，也就是docker容器的根目录。在启动docker容器时，会先为容器挂载Rootfs，并设定为只读模式，同时采用union mount技术，在Rootfs上挂载一个读写的空文件系统。
2、接下来谈谈docker的网络架构
众所周知，docker网络有四种模型，bridge，host，container，none
2.1、bridge
网络模型如下图

docker会为容器创建独有的network namespace，也会为这个命名空间配置好虚拟网卡，路由，DNS，IP地址与iptables规则（也就是sandbox的内容）。
2.2、host模式

在这个模式下，容器和宿主机共享一个network namespace，而不会单独获得单独的network namespace。这意味着，容器不会单独配置网卡，IP地址，而是用宿主机的，但是在这一模式下，容器内的很多操作很直接影响到宿主机，比如重启，所以这一模式并不是很推荐。
2.3、container模式，在这一模式下，docker将新建容器放到一个已知的容器网络栈中，这样会和已存在的容器共享IP和端口等网络资源，两者可通过lo回环接口进行通信。
2.4、none，不配置网络，这个需要用户自行配置网络。
3、那么docker的安全性呢
3.1、可以说，docker出现安全问题的主要原因在于容器和宿主机共享内核，因为namespace只提供了PID、Mount、Network、UTS、IPC、User这几个属性的隔离，其他资源会存在暴露的风险，假如出现宿主机资源滥用，有概率导致宿主机崩溃。其次，docker源，docker自身，DDos攻击，局域网攻击等也存在安全问题。那么应该如何应对呢？
3.2、docker安全措施
1>及时更新内核，现在一般更新到4.4.X的就可以了，如果有新问题出现，再根据需求更新即可。
2>检查Cgroup，对资源进行配额和限定，不过最新版的docker已经支持了通过docker命令行进行资源限制，可通过命令行配置即可，当然，直接修改cgroup进行限制也是可以的。
3>严禁将宿主机上的敏感目录映射到容器，比如/etc目录
4>仅运行必要的服务，禁止SSH服务
5>对docker的守护进程，文件，目录进行审计，并限制root权限的docker文件访问权限为644甚至更低
6>清理不必要的容器
7>严禁使用host网络模式，严禁映射到特权端口
8>创建本地镜像仓库，确保镜像，软件来源均可信，并采用安全扫描
9>限制重启次数，避免频繁重启导致雪崩
10>使用普通用户启动docker

可以说docker是包罗万象的，本文只是先简单进行一下讨论，从下一篇文章开始，将论述我和docker更多的故事

一、为什么要用jenkins呢？
在当今的互联网环境下，devops大行其道，成为了一个热度越来越高的概念，而贯穿整个devops工作流的则是编码 → 提交 → 测试 → 部署 → 交付。而jenkins 是一个基于Java开发的一个开源的CICD工具，同时支持丰富的插件扩展，也可以开发适合自己团队使用的工具，如git，svn，maven，docker等。
那么CICD是什么呢？
持续集成（Continuous integration）指的是，频繁地（一天多次）将代码集成到主干。将软件个人研发的部分向软件整体部分交付，频繁进行集成以便更快地发现其中的错误。
持续交付（Continuous delivery）指的是，频繁地将软件的新版本，交付给质量团队或者用户，以供评审。如果评审通过，代码就进入生产阶段。
那么这样做有什么好处呢？
首先，可以保持代码是始终处于可发布到生产的状态，同时也可以快速发现定位问题。其次，可以防止分支大幅偏离主干。第三，持续测试及部署测试环境可以压缩部署生产前的等待时间，将整个流程自动化，为devops实现奠定基础。

笔者公司在devops评估中通过了三级，回顾整个devops架构，发现此架构无可移植性，故此决定对标此架构，进行进一步的探索，第一入手点决定放在devops工具中，至关重要的一节，jenkins。

二、jenkins环境部署
2.1、环境配置
2C4G
JAVA8
TOMCAT8

2.2、部署jenkins
2.2.1、部署JAVA8
这里选择使用openjdk
yum -y install java-1.8.0-openjdk*

2.2.2、部署TOMCAT8
tar zvxf apache-tomcat-8.5.56.tar.gz
mv apache-tomcat-8.5.56 /opt

2.2.3、部署jenkins
cd /opt/apache-tomcat-8/webapps/ROOT/
rm -rf *
cp ~/jenkins.war .
unzip jenkins.war

2.2.4、启动jenkins
sh /opt/apache-tomcat-8/bin/start.sh
访问 http://IP:8080
主要注意的是，这里会提示安装插件，一定要跳过

2.2.5、修改/root/.jenkins/updates/default.json
sed -i ‘s/www.google.com/www.baidu.com/g' default.json
sed -i ‘s/updates.jenkins-ci.org/download/mirrors.tuna.tsinghua.edu.cn/jenkins/g’ default.json
将下载源更换成清华源，在重启jenkins即可

2.3、插件安装
安装一些用得到的就行，比如pipeline，比如gitlab相关的，这个很灵活，按需求来就行了

2.4、提供一个国内的镜像，下载速度超级快
https://mirrors.huaweicloud.com/jenkins/

一、事故背景
nexus 因产生脏数据导致数据不一致，生成大量日志文件，并且并发的有OOM，nexus服务挂了

二、紧急灾难处理
1、通过最新的nexus备份数据进行备机启动，先恢复服务避免影响扩大
2、因域名切换需要一定时间，在切换域名指向IP前先检查备份数据正确性
进入nexus工作目录/opt/nexus/后执行命令java -jar ./lib/support/nexus-orient-console.jar 进入orientdb命令行
3、执行命令：CONNECT PLOCAL:/opt/sonatype-work/nexus3/db/${dbname} admin admin 连接到数据库并执行命令检查数据文件
REBUILD INDEX *

REPAIR DATABASE –fix-graph

REPAIR DATABASE –fix-links

REPAIR DATABASE –fix-ridbags

REPAIR DATABASE –fix-bonsai
4、修复完毕后修改文件属主属组为nexus，并启动nexus备库，至此，备库开始提供服务

三、事故定位
1、查看日志，发现日志报错如下

经确认，assetdownloadcount记录的是asset下载次数的数据，报错是因为记录delete失败，该表数据并不重要，故采用人工删除的方式解决，筛选日志，发现需要删除的表为truncate cluster assetdownloadcount_3，truncate cluster assetdownloadcount_5，truncate cluster assetdownloadcount_10，truncate cluster assetdownloadcount_15
2、尝试启动服务，发现有日志报错为


定位为INDEX quartz_job_detail_name_group_idx重复导致

四、事故处理
1、进入/opt/nexus/目录下，执行命令：java -jar ./lib/support/nexus-orient-console.jar 进入orientdb命令行，并执行命令：CONNECT PLOCAL:/opt/sonatype-work/nexus3/db/component admin admin 连接到component库后执行命令：

truncate cluster assetdownloadcount_3

truncate cluster assetdownloadcount_5

truncate cluster assetdownloadcount_10

truncate cluster assetdownloadcount_15

删除有问题的cluster
2、执行命令：CONNECT PLOCAL:/opt/sonatype-work/nexus3/db/config admin admin 连接到config库
执行命令：drop INDEX quartz_job_detail_name_group_idx

3、依次修复所有库的数据
REBUILD INDEX *

REPAIR DATABASE –fix-graph

REPAIR DATABASE –fix-links

REPAIR DATABASE –fix-ridbags

REPAIR DATABASE –fix-bonsai
4、重启nexus 发现服务正常，日志输出正常，至此，问题完美解决
5、修改数据备份策略，此时主备库以互换

一、容器：存储和组织数据的方式
变量在一定程度上能满足函数及代码要求。如果编写一些复杂算法、结构和逻辑，就需要更复杂的类型来实现。这类复杂类型一般情况下具有各种形式的存储和处理数据的功能，将它们称为“容器（container）”。在很多语言里，容器是以标准库的方式提供，你可以随时查看这些标准库的代码，了解如何创建，删除，维护内存。

1、数组：一段固定长度$的连续内存区域。可修改成员，但是数组大小不可变。
声明数组
var 数组变量名 元素数量T
a、元素数量不能含有到运行时才能确认大小的数值
b、T可以是任意类型
c、多维数组：多个一维数组组成

2、初始化数组
使用初始胡列表进行元素设置
var lesson = [3]string{“math”, “english”, “code”}

也可由编译器确认数组大小
var game = […]{“DOTA2”,”CSGO”,”war3”}
“…” 标识让编译器确定数组大小

3、切片（slice）

切片的内部结构包含地址、大小和容量。切片一般用于快速的操作一块数据集合。
从哪儿开始切数据，切多大的数据。
格式 slice [开始位置:结束位置]
例子：
var a = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])

切片增加了大小的限制，约束了切片对应内存区域，切片使用中无法对切片内部的地址和大小进行手动调整，因此更安全。
4、声明切片
每一种类型都可以拥有其切片类型，表示多个类型元素的连续集合。因此切片类型也可以被声明。
var name []T
var stringlist []string //声明字符串切片
var numlist []int //声明整型切片
var Emptylist []int{} //声明空切片
fmt.Println(len(strList), len(numList), len(EmptyList)) //输出切片大小
fmt.Println(strList, numList, EmptyList) //输出三个切片
fmt.Println(stringlist == nil) //判断切片为空的结果

5、使用make()函数构造切片
make( []T, size, cap )
T:切片的类型
size：切片的元素数量
cap：预分配数量，不影响size，可以降低多次分配空间造成的性能问题

案例：
a := make([]int, 2)
b := make(len(a), 2, 10)

fmt.Println(a, b)
fmt.Println(len(a), len(b))
使用make()函数生成的切片一定发生了内存分配操作，但是给定开始和结束位置的切片，只是将新的切片结构指向已经分配的内存区域，设定开始和结束的位置，不会发生内存分配操作。

6、为切片动态添加元素
append()函数可以对切片进行扩容，扩展规律为2的倍数
var game []string

game = append(game, “DOTA2”, “WAR3”)
oldgame := []string{“大话西游”, “仙剑奇侠传”}

game = append(game, oldgame…)
“…”表示将整个 oldgame添加进去

7、复制切片元素到另一个切片
案例：
package main
import “fmt”

func main() {

const pipelie = 10000

srcData := make([]int, pipelie)

for i := 0; i < pipelie; i++ {
    srcData[i] = i
}

refData := srcData

copyData := make([]int, pipelie)
copy(copyData, srcData)

srcData[0] = 999
fmt.Println(refData[0])
fmt.Println(copyData[0], copyData[pipelie-1])
copy(copyData, srcData[4:6])

for i := 0; i < 5; i++ {
    fmt.Printf("%d ",copyData[i])
}

}

8、从切片中删除元素，只能通过切片本身的特性来删除，go未提供语法和接口
seq := []string{“a”, “b”, “c”, “d”, “e”}
index := 2
fmt.Println(seq[:index], seq[index+1:])
seq = append(seq[:index], seq[index+1:]…)
fmt.Println(seq)
以被删除元素为分界点，将前后两部分内存重新连接起来

9、映射（map）
map [keytype]valuetype

案例：
game := make(map[string]int)

game[“DOTA2”] = 1111
fmt.Println(game[“DOTA2”])

dota := game[“war3”]
fmt.Println(dota)

10、删除map中的键值对
delete(map, key)
案例：
delete(game, “DOTA2”)
for k, v := range game {
fmt.Println(k, v)
}

但无法清空map 只能重新make一个map

11、并发 go1.9引入了sync.Map
案例：
package main
import (
“fmt”
“sync”
)

func main() {
var game sync.Map
// 将kv保存到sync.Map
game.Store(“DOTA2”, 1)
game.Store(“csgo”, 2)
game.Store(“war3”, 3)
fmt.Println(game.Load(“war3”))
game.Delete(“war3”)
game.Range(func(k, v interface{}) bool {
fmt.Println(“排名”, k, v)
return true
})
}
sync.Map 保证了并发的安全，但是损失了一些性能

一、go语言中包的使用
1、包（package）
go语言的入口main函数所在的包，main包想引用别的代码，需要import。
如下图所示

这里导入了两个工程内自定义的包，util和utiltime，并且在主函数main中调用了自定义包中的函数
下面看一下两个自定义包

在工程study目录下创建了util目录，在util目录下的go文件会默认生成一个package

在util目录下又创建了utiltime目录（嵌套结构）

再返回看main函数，所引包中的函数首字母为大写的，才可以在其他包中或者函数中引用，若为小写仅可在本包中引用

总结一：关于包的使用
a、一个目录下的文件统一归属一个包，package的声明要一致
b、package声明可以和目录不一致，但同一目录下的声明必须一致
c、包可以使用嵌套结构
d、同包下的函数不需要导入包
e、main包为main函数所在的包
f、导入包的时候要从src目录写起，或是使用相对目录
g、导入包可以配置别名

2、init()包初始化
a、init()函数会优先于main()函数执行，初始化数据
b、定义时不能有任何返回值和参数，这一点和main函数是一样的init函数可以存在于任意包中，可以定义多个
c、init函数可以存在于任意包中，可以定义多个
d、同一个go文件中，从上到下调用，同一个package中，按文件名字符串从小到大排序，不同的package中，若不互相依赖，则按照main包中import顺序，若存在依赖关系，则最后被依赖的最先被初始化。
e、存在依赖的包之间，不能循环导入
f、一个包可以被多次import，但只能初始化一次
g、值初始化某个包中的init()函数，单不执行其他内容，可以在导入包时加下划线，example import _ “utils”

3、管理外部包
a、clone下来外部包，copy到gopath的src目录下（纯内网）
b、go get ${path} go get github.com/go-sql-driver/mysql

二、工程目录结构
GOPATH是go的开发目录，目录结构如下

云原生和devops越演越烈的今天，运维的要求越来越高了，为此特意决定开启go学习之路。此为学习笔记
第一天：go基础语法

一、申明变量
1、声明变量
var a int //整型，保存整数数值
var b string //字符串类型
var c []float32 //32位浮点型
var d func() bool //布尔型的函数变量
var e struct{ // 声明一个结构体类型的变量
x int // 拥有一个整型x字段
}

/* 除此之外还可以用一种懒汉型的变量申明方式
用var 和括号 将一组变量放在一起
*/

var (
a int
b string
c []float32
d func() bool
e struct{
x int
}
)

变量在声明时，go语言自动会对变量对应的内存区域进行初始化操作，每个变量会初始化成其类型的默认值
int float ： 0
string ： 空
bool ： false
切片，函数，指针：nil
当然了，也可以在声明时赋值

2、声明变量的标准格式
var 变量名 类型 = 表达式
例如：
初始财产为100
var gold int = 100

3、短变量声明并初始化
var声明的精简写法
gold := 100

注意！！！：当使用 := ，推导声明写法左侧必须是没有定义过的变量。在多个短变量声明和赋值中，至少有一个新声明出现在左值中，编译器便不会报错。

4、多个变量同时赋值
变量交换
var a int = 100
var b int = 200
b,a = a,b
fmt.Println(a,b)

5、匿名变量
多重赋值时，如果不需要在左值中接受变量，可使用匿名变量_
例如：
func GetWeight() (float32,float32) {
return 90.51,86.72
}
a, _ := GetWeight()
_, b := GetWeight()
fmt.Println(a,b)

代码输出
90.51 86.72

二、数据类型
1、整型
按长度分为：int8、int16、int32、int64
无符号整型：uint8、uint16、uint32、uint64

其中uint8 为byte型，uint16 对应c语言的short型，unit64对应c语言中的long型

注意：在使用 int和uint时，要考虑在不同平台上的差异

2、浮点型
Go语言支持两种浮点型：float32和float64，遵循IEEE754标准
float32的浮点数的最大范围为3.4e38 可用定义为常量： math.Maxfloat32
float64的浮点数的最大范围为1.8e308 可用定义为常量：math.Maxfloat64
打印浮点数时，可以使用fmt包配合动词”%f”
代码如下

输出结果如下

3、bool型
Go语言中不允许强制转换为bool型

4、字符串
字符串在go语言中以原生数据类型出现，为双引号中的内容
例如：
单行字符串
str := “Hello World”
ch := “中文”
多行字符串
const str = line1 line2 line3
字符串中的每一个元素则称为字符，字符有以下两种：
1、unit8 也会是byte型，代表了ASCII码的一个字符
2、rune 也就是int32，代表一个UTF-8字符，常用于处理中文，日文等
可以通过fmt.Printf中的%T来输出类型
例如：
代码如下

输出结果为

字符串这里会涉及到转义符如下

三、指针
指针地址：每个变量在运行时都有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&操作符放在变量前面对变量进行取地址操作。
例：
ptr := &v // v的类型为T

v表示被取地址的变量，被取地址的v使用ptr进行接收，ptr的类型为T，称作T的指针类型，代表指针
指针使用代码案例如下：

package main

import “fmt”

func main() {
var cat int = 1 //声明整型变量cat
var str string = “applt” //声明字符串变量str
fmt.Printf(“%p %p”, &cat, &str) //%p输出指针
}

执行结果为
0xc00006e090 0xc0000561e0 //0x为16进制前缀，输出结果每次均不会相同，代表变量运行时的地址

package main

import “fmt”

func main () {
//声明字符串
var flower = “腰花”

//对字符串取地址
ptr := &flower

//打印ptr指针类型
fmt.Printf("type: %T\n", ptr)

//打印ptr指针地址
fmt.Printf("address: %p\n", ptr)

//对指针取值
value := *ptr

//取值后的类型
fmt.Printf("type: %T\n", value)

//指针取值后就是指向变量的值
fmt.Printf("value: %s\n", value)

}
执行结果如下
type: *string
address: 0xc0000421f0
type: string
value: 腰花

取地址操作符&和取值操作符是一对互补的操作符，&取地址，根据地址取出地址指向的值

变量、指针地址、指针变量、取地址、取值的相互关系和特性

a、对变量进行取地址&操作，可以获取这个指针变量指向的原变量的值
b、指针变量的值是指针地址
c、对指针变量进行取值*操作，可以获得指针变量指向的原变量的值

使用指针进行数值交换来修改值
代码如下
package main

import “fmt”

//交换函数
func swap(a,b int) { //int，指针类型
//取a指针的值
t := *a

//取b指针的值
*a = *b

//将a指针的值赋给b指针指向的变量
*b = t

}

func main() {
//变量赋值3 4
x,y := 3,4

//交换变量
swap(&x, &y)

//输出变量
fmt.Println(x,y)

}
输出结果为
4 3

*操作符的根本意义就是操作指针指向的变量，当操作在右值时，就是取指向变量的值，当操作在左值时，就是将值设置给指向的变量。

四、栈
栈（stack）：一种拥有特殊规则的线性表数据结构，只允许往代表线性表的一端放入数据，之后在这一端取出数据，按照后进先出的顺序（LIFO,LAST IN FIRST OUT）
往栈中放入数据叫做入栈，增加栈的元素数量，最后放入的元素总是位于栈的顶部，最先放入的数据总是位于栈的底部。不允许从栈底获取数据，也不允许对栈的成员进行任何查看和修改。

变量和栈的关系：栈可以用于内存分配，栈的分配和回收速度非常快。
下面代码可以用来展示栈在内存分配上的作用
package main

import (
“fmt”
)

func calc(a,b int) int {
var c int
c = a * b
var x int
x = c * 10
return x
}

func main() {
var y int = calc(3,4)
fmt.Printf(“%d”, y)
}

堆和栈相笔，堆适合不可预知大小的内存分配，但是速度较慢，并且会形成内存碎片

堆（heap）
二、变量逃逸（Escape Analysis）
go语言的编译器中有变量逃逸分析，由编译器分析代码的特征和代码生命周期，决定应该如何堆还是栈进行内存分配。
1、逃逸分析
package main

import “fmt”

//本函数测试入口参数和返回值情况
func dummy(b int) int {

//声明一个c赋值进入参数并返回
var c int
c = b
return c

}

//空函数，什么都不做
func void() {

}

func main() {

//声明a变量并打印
var a int

//调用void()函数
void()

//打印a变量的值和dummy()函数返回
fmt.Printfln(a, dummy(0))

}
执行命令行
go run –gcflags “-m -l” study3.go
D:\GO\golang\src\awesomeProject\studyday1>go run –gcflags “-m -l” study3.go

command-line-arguments

.\study3.go:28:13: main … argument does not escape //默认提示
.\study3.go:28:13: a escapes to heap //第28行a 逃逸到堆
.\study3.go:28:22: dummy(0) escapes to heap //dummy逃逸到堆
0 0

2、取地址发生逃逸
代码如下

package main

import “fmt”

//声明空结构体测试结构体逃逸情况
type Data struct {

}

func dummy() *Data {

//实体化c为Data类型
var c Data

//返回函数局部变量地址
return &c

}

func main() {

fmt.Println(dummy())

}

D:\GO\golang\src\awesomeProject\studyday1>go run –gcflags “-m -l” study3.go

command-line-arguments

.\study3.go:13:6: moved to heap: c //将c移动到堆中
.\study3.go:21:13: main … argument does not escape
.\study3.go:21:19: dummy() escapes to heap
&{}

堆和栈的原则：
变量是否被取地址
变量是否发生逃逸

　　docker容器的制作方式主要为两种，第一种为从容器构建镜像，即容器镜像，通过docker commit 的方式进行构建，该方法本菜鸟并不推荐，原因有如下几点：1）镜像为分层结构，容器则为镜像顶层加了一个可写层，这一方式构建的镜像极容易镜像过大。2）容器镜像无法确定这一层可写层内的内容，对于安全性上，存在问题，而且也不易维护。

　　第二种镜像构建的方法则为dockerfile，通过dockerfile来控制镜像的构建。这个也是官方推荐的方案，同时毕业也推崇此方案。

　　dockerfile为一个纯文本文件，通过指令来控制构建，常用指令如下：

　　1.FROM 此指令后面跟随的为基础镜像。例如:FROM centos:7 引用基础镜像centos:7

　　2.MAINTAINER 此指令用于维护构建者信息。例如:MAINTAINER XuPangzi Pangzi@example.com

　　3.LABEL 用于添加标签。例如:LABEL BASE FOR SPRING-CLOUD

　　4.COPY 用于拷贝文件，不解压。例如:COPY tomcat.tar /opt/

　　5.ADD 用户拷贝文件，可解压。例如:ADD tomcat.tar /opt/

　　6.RUN 用于执行shell命令。例如:RUN mkdir -p /app/{log,data,conf,lib}

　　7.WORKDIR 用于设置工作目录，即进入容器后的默认目录。例如:WORKDIR /app

　　8.USER 为运行shell命令的用户。例如:USER app

　　　　　　　　　　　　　　　　　　　USER app:app

　　　　　　　　　　　　　　　　　　　USER 500

　　　　　　　　　　　　　　　　　　　USER 500:500

　　　　　　　　　　　　　　　　　　　USER app:500

　　　　　　　　　　　　　　　　　　　USER 500:app

　　9.EXPOSE 声明端口。例如:EXPOSE 8881

　　10.ENV 环境变量。例如:ENV MYSQL_PORT 8306

　　11.ENTRYPOINT 容器启动时执行的命令，不会被docker run 覆盖。例如:ENTRYPOINT [“/bin/bash”,”-C”,”/opt/apache-tomcat/start.sh”] exec 风格 ENTRYPOINT /bin/bash -C /opt/apache-tomcat/start.sh shell风格

　　12.CMD 容器启动时执行的shell命令

　　谈完dockerfile，该谈一下构建镜像了。通常都是采用 docker build -t example:v1 . 在dockerfile所在目录执行即可，同时ADD和COPY的文件也需要在dockerfile同级，不过为了匹配流水线作业，通常会采用另外一种方式进行构建:

　　1.用户自备dockerfile 同时dockerfile以应用来命名，例如APP1_dockerfile，在构建镜像时，执行命令 docker build –no-cache=true -t app_A:v1 -f APP1_dockerfile .

　　2.将dockerfile植入到构建脚本中，通过构建是引入的参数来生成dockerfile 同时构建镜像，此方式下仍建议采用命令docker build –no-cache=true -t app_A:v1 -f APP1_dockerfile .

　　实践：

　　1.镜像最好是自己构建，从dockerhub或其他平台pull的私人镜像，无法保证是否里面埋有不安全插件，为了保障安全，推荐自己构建镜像

　　2.选择恰当的基础镜像，核心应用，选择较大且稳定的镜像，比如centos，ubuntu，但该镜像的缺点是容易使生成的业务镜像较大，比如centos7+java8+tomcat+应用，轻松过G，若是前端等，则可以使用小巧的基础镜像，比如alpine，busybox，debian等，但该镜像也有不足，镜像追求轻量级，很多基础工具都没有，需要用户自行安装。

　　3.构建镜像时要保证层数尽可能的少，此处有一技巧，RUN 后面可跟随多条shell命令，以&链接，同时执行完后一定要记得删除无用文件，以保障镜像最小化。

　　所以基于以上几点，可根据公司需求，构建几版基础镜像，比如1、alpine+nginx+lua+curl+telnet等网络调试工具的前端基础镜像。2、alpine+java+tomcat+curl+telnet等调试工具的java基础镜像。3、基于centos和Ubuntu的核心服务镜像。等等等等，将基础镜像构建好后，就可以根据基础镜像设计持续集成流水线来自动化构建业务镜像了。

　　继续聊聊基础镜像

　　1、busybox

　　此镜像集成了上百个linux常用命令，且镜像极小，大约2M，通过docker pull busybox:latest 即可，这个通常用来进行测试，比如写个yaml啥的

　　2、alpine

　　此镜像为一个轻量级安全向镜像，大小仅5M，关注安全，性能，资源效能，通过docker pull alpine可拉取镜像。鉴于我很多镜像都基于此镜像，这里多叨叨几句。此镜像采用apk安装应用，可在dockerfile

中添加源

　　中科大源：echo “http://mirrors.ustc.edu.cn/alpine/" > /etc/apk/repositories

　　阿里源：echo “http://mirrors.aliyun.com/alpine/" > /etc/apk/repositories

　　清华源：echo “https://mirror.tuna.tsinghua.edu.cn/alpine/" > /etc/apk/repositories

　　apk –update add –no-cache

　　即可安装，不过记得在安装后删除缓存，使镜像保持最小

　　3、ubuntu/centos

　　这两个属于重量级的镜像，就放在一起说吧，比较稳定，不过就是容易搞的镜像超大，轻松过G，恐怖如斯，如果有需要jdk和tomcat来运行的java应用，请做好思想准备

　　参考资料：

　　1.你必须知道的Dockerfile https://www.cnblogs.com/edisonchou/p/dockerfile_inside_introduction.html https://www.cnblogs.com/edisonchou/

　　2. Dockerfile命令详解 https://www.cnblogs.com/yanh0606/p/11360936.html

　　3.Dockerfile 中的 COPY 与 ADD 命令 https://www.cnblogs.com/sparkdev/p/9573248.html http://www.cnblogs.com/sparkdev/

　　4.容器技术之Dockerfile （一） https://www.cnblogs.com/qiuhom-1874/p/13019411.html https://www.cnblogs.com/qiuhom-1874/

一、背景
公司计划做devops技术栈，在制品库选型时选择了SonatypeNexus作为制品管理工具。Sonatype nexus 是sonatype公司的一款制品管理工具，自身提供了OSS 开源免费版及PRO商业版，同时nexus自身具有多方面的优势，首先，管理制品种类多，可以管理maven，docker，npm，go等主流语言的制品，同时在权限配置和用户配置上具有的优势，可以实现针对制品的降权处理。同时官方也提供了丰富的api文档，可以灵活的针对nexus进行二次开发，实现devops工具的多种需求。
二、工具下载
Nexus提供了二进制部署及镜像部署这两种方式，首先二进制部署可通过https://help.sonatype.com/repomanager3/download/download-archives---repository-manager-3 下载，镜像可通过https://hub.docker.com/r/sonatypenexus3/tags/ 进行下载。PS:1、站点在国外，所以二进制下载常常会出现下载失败的现象，这个可以可以通过反复下载赌运气，或者是买一个其他地区的服务器转发（成本好高呀）2、镜像下载就好多了，可以通过阿里云的加速器，下载速度还是让人可以接受的。

三、服务部署
3.1 部署需求
官方建议配置如下
CPU:最少为4，推荐为8+
内存:建议8G起步，规模大可考虑16G甚至是32G+
JAVA:JDK8
句柄数:至少为65536
磁盘空间:多多益善，官方建议500G

综合考虑我公司现状，nexus配置为
CPU：8核
内存：16G
存储：500G

3.2 服务部署
部署这里共探索了两种主流方案，方案如下
方案一、二进制部署
1、 创建程序用户

useradd nexus

2、 修改句柄数

在 /etc/security/limits.conf 中添加

nexus - nofile 65536

3、 重启服务

reboot

4、 部署java

tar zvxf jdk-8u231-linux-x64.tar.gz

mv jdk-8u231 /opt/jdk

修改 /etc/profile

export JAVA_HOME=/opt/jdk

export PATH=$JAVA_HOME/bin:$PATH

export CLASSPATH=.:$JAVA_HOME/lib:$JAVA_HOME/jre/lib:$JAVA_HOME/lib/tools.jar

保存后执行 source /etc/profile

5、 部署nexus

cd /opt

wget http://download.sonatype.comnexus/3nexus-3.24.0-02-unix.tar.gz

tar zvxf nexus-3.24.0-02-unix.tar.gz

mv nexus-3.24.0-02 nexus

cd nexus/bin

在nexus 中修改第14行

INSTALL4J_JAVA_HOME_OVERRIDE=

为java的部署路径否则有概率启动报错

在nexus.rc中修改为

run_as_user=”nexus”

在/optnexus/etcnexus-default.properties中可修改默认端口（可选）

修改文件权限

chown -R nexus:nexus /optnexus

chown -R nexus:nexus /opt/sonatype-work

切换用户，启动服务

su nexus

cd /optnexus/bin

.nexus start

方案二 容器部署
docker run \

-p 8081:8081 \

–name nexus \

–ulimit nofile=65536:65536 \

–restart always \

sonatypenexus3

即可完成部署

PS：一般情况下默认的登录信息为admin/admin123，不过有的时候会提示密码错误，这个时候就需要找一下/opt/sonatype-worknexus3目录下的admin.password文件，使用该密码登陆后会提示用户设置admin密码。

两种部署方案均做过尝试后，决定采用方案一中作为公司使用方案
1、nexus在使用中需要频繁读写，docker自身存在io低的短板，会降低nexus的效率
2、docker存在不稳定的短板，nexus作为公共工具，一旦出现问题将严重阻塞公司开发进度
3、nexus为工作目录和数据目录分离的架构设计，使用二进制部署可以轻松进行服务升级以及服务扩展（需要扩展备机时，将数据打包即可）

五、nexus配置
5.1 配置数据仓库
登录nexus后，可以按照如下顺序点击，即可创建私服仓库了

可以看到支持的存储种类是非常多的

仓库类型主要分为

proxy：代理公网上的仓库，比如maven的中央仓库，node的阿里镜像

hosted：本地仓库，一般是私有仓库，用于发布自己公司开发的制品

group：组，把几个仓库结合在一起，方便下载制品
5.1.1 创建proxy代理仓库
1、选择npm（proxy）

2、命名并输入代理地址，保存

3、本地配置npm config或npm install时指定为私服代理

4、安装成功后产看代理仓库，发现已经缓存下来刚刚安装的node依赖了

5.1.2 创建hosted仓库
创建maven（hosted）

选择maven2（hosted）仓库

配置仓库名，仓库中可保存包的version规则，上传规则后保存。


其中vesion规则里面，release为发布版，snapshot为快照版，mixed为混合，建议release和snapshot分开保存，同时严格遵守版本规则。其中发布版release突出其稳定性，所以禁止redeploy，如果包变更，请升级版本号。

配置完毕的仓库（私服）

PS:上传jar包

方案一：有项目源码时，通过maven命令，打包源码后上传，在构建时，可在settings.xml中配置Repository标签和server标签，然后通过mvn deploy命令上传到对应私服仓库。

方案二：通过调用接口上传

POST /service/rest/v1/components

curl -v -u admin:admin123 -X POST ‘http://192.168.1.62:8081/repository/example_maven_release/' -F maven2.groupId=com.google.guava -F maven2.artifactId=guava -F maven2.version=24.0-jre -F maven2.asset1=@guava-24.0-jre.jar -F maven2.asset1.extension=jar -F maven2.asset2=@guava-24.0-jre-sources.jar -F maven2.asset2.classifier=sources -F maven2.asset2.extension=jar

方案三：在只有j制品时，通过maven命令直接上传

mvn deploy:deploy-file -Dfile=guava-24.0-jre.jar -DpomFile=guava-24.0-jre.pom -Dpackaging=jar -DrepositoryId=bxbank_privrepository_snapshots -Durl=http://192.168.1.62:8081/repository/example_maven_release/

5.1.3 创建group

创建npm（group）

npm因自身有多个代理可选择，所以可以选择group的模式来实现配置后可从多个npm代理中下载依赖的目的

配置组名及npm组中需要的代理及私服

配置完毕

PS:配置组（group）主要是为了方便用户拉取依赖

5.2 用户配置
5.2.1 创建角色
按下图依次点击进入roles界面

根据仓库分别创建ReleaseUploader，SnapshotUploader，NpmUploader的角色

在创建权限时，可通过搜索功能缩小范围，如图搜索npm，在这里会发现根据创建的example_npm仓库，出现了对应的规则，例如nx-repository-admin-npm-example_npm-* ,需要将这些规则移动到右侧，再点击保存即可。同理可创建ReleaseUploader，

至此，角色创建完毕
5.2.2 创建账号
按照下图顺序进入users界面

点击create local user，依次输入用户名，email，密码等，并配置之前创建的角色

配置基本信息

配置角色并设计帐号状态为激活

并以相同的方式创建ReleaseUploader和SnapshotUploader，至此，公共账号创建完毕，可依照此方案创建所需要的帐号。

六、高可用方案

nexus因其自身有pro，并且将HA配置在了pro版，所以只能走野路子了。网上可以找到的方案为rsync，不过这个方案服务器负载过高，不太实用，所以采用另一个方案了。

个人设计的方案为全量备份，备机高速恢复服务策略：
1、每天定时全量备份（夜晚），全备保存三份即可
2、nexus访问通过域名访问
3、出现问题，通过备份数据重启服务即可
方案缺陷：
1、会缺失全备时间点到当前时间点的制品
2、服务恢复需要一定时间，无法做到无感知