404频道

学习笔记

Posted on Edited on

pushd和popd命令的用法

在编写shell的时候，经常会在目录之间进行切换，如果使用cd命令经常会切换错误，pushd和popd使用栈的方式来管理目录。

dirs

用于显示当前目录栈中的所有记录。

pushd

将目录加入到栈顶部，并将当前目录切换到该目录。若不加任何参数，该命令用于将栈顶的两个目录进行对调。

popd

删除目录栈中的目录。若不加任何参数，则会首先删除目录栈顶的目录，并将当前目录切换到栈顶下面的目录。

命令格式：pushd [-N | +N] [-n]

  • +N 将第N个目录删除（从左边数起，数字从0开始）
  • -N 将第N个目录删除（从右边数起，数字从0开始）
  • -n 将目录出栈时，不切换目录

example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@localhost tmp]# mkdir /tmp/dir{1,2,3,4}
[root@localhost tmp]# pushd /tmp/dir1
/tmp/dir1 /tmp
[root@localhost dir1]# pushd /tmp/dir2
/tmp/dir2 /tmp/dir1 /tmp
[root@localhost dir2]# pushd /tmp/dir3
/tmp/dir3 /tmp/dir2 /tmp/dir1 /tmp
[root@localhost dir3]# pushd /tmp/dir4
/tmp/dir4 /tmp/dir3 /tmp/dir2 /tmp/dir1 /tmp
# dirs的显示内容跟pushd完成后的输出一致
[root@localhost dir4]# dirs
/tmp/dir4 /tmp/dir3 /tmp/dir2 /tmp/dir1 /tmp

[root@localhost dir4]# popd
/tmp/dir3 /tmp/dir2 /tmp/dir1 /tmp

# 带有数字比较容易出错
[root@localhost dir3]# popd +1
/tmp/dir3 /tmp/dir1 /tmp

# 清除目录栈
[root@localhost dir3]# dirs -c
[root@localhost dir3]# dirs
/tmp/dir3

Posted on Edited on

docker image结构

docker可以通过命令docker image inspect ${image}来查看image的详细信息，其中包含了所使用的底层文件系统及各层的信息。

docker container的存储结构分为了只读层、init层和可读写层。

只读层跟docker image的层次结构恰好对应，主要包含操作系统的文件、配置、目录等信息，不包含操作系统镜像。

init层在只读层和读写层中间，用来专门存放/etc/hosts /etc/resolv.conf等信息，这些文件往往需要在启动的时候写入一些指定值，但不期望docker commit命令对其进行提交。

可读写层为容器在运行中可以进行写入的层。

overlay

image

采用了两层结构，lowerdir为镜像层，只读。upperdir为容器层。

每层都会在/var/run/docker/overlay创建一个文件夹，文件夹中为实际层的内容，文件采用硬链接的方式链接到真实层中的文件，每一层都包含该层该拥有的所有文件，而该文件的真实存储可能是采用硬链接的方式链接到上层中的真实文件，因此比较耗费inode。

创建一个容器时，会新增两个目录，一个为读写层，一个为初始层。初始层中保存了容器初始化时的环境信息，如hostname、hosts文件等。读写层用于记录容器的所有改动。

overlay2

为了规避overlay消耗inode节点过多的问题，overlay2采用在每层中增加lower文件的方式来记录所有底层的信息，类似于链表的形式。

docker pull ubuntu

1
2
3
4
5
6
7
8
9
10
[root@localhost runc]# docker pull ubuntu
Using default tag: latest
latest: Pulling from library/ubuntu
c64513b74145: Pull complete
01b8b12bad90: Pull complete
c5d85cf7a05f: Pull complete
b6b268720157: Pull complete
e12192999ff1: Pull complete
Digest: sha256:3f119dc0737f57f704ebecac8a6d8477b0f6ca1ca0332c7ee1395ed2c6a82be7
Status: Downloaded newer image for ubuntu:latest

会在/var/run/docker/overlay2目录下创建如下文件：

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
[root@localhost overlay2]# tree -L 2
.
|-- 664ae13f1c21402385076025d68476eb8d1cc4be6c6a218b24bd55217ac62672    // 第0层
|   |-- diff
|   `-- link    // MZUEUOFHBNVTRCJYJEG7QY4VWT
|-- 783ad02709b67ac47b55198e9659c4592f0972334987ab97f42fd10f1784cbba    // 第2层
|   |-- diff
|   |-- link    // HXATFASQ4E2JBG434DUEN54EZZ
|   |-- lower   // l/WUZC5WSTQTPJUJ4KFAYCUT5IPD:l/MZUEUOFHBNVTRCJYJEG7QY4VWT
|   |-- merged
|   `-- work
|-- 89f7a20dda3d868840e20d9e8f1bfe20c5cca51c27b07825f100da0f474672f6    // 第3层
|   |-- diff
|   |-- link    // 5PHT7S3MCZTTQOXVPA4CKJRRFD
|   |-- lower   // l/HXATFASQ4E2JBG434DUEN54EZZ:l/WUZC5WSTQTPJUJ4KFAYCUT5IPD:l/MZUEUOFHBNVTRCJYJEG7QY4VWT
|   |-- merged
|   `-- work
|-- backingFsBlockDev
|-- bad073a2d1f79a03af6caa0b3f51a22e6762cebbc0c30e45458fe6c1ff266f68    // 第4层
|   |-- diff
|   |-- link    // QMKHIPSDT4JTPE4FLT7QGJ33ND
|   |-- lower   // l/5PHT7S3MCZTTQOXVPA4CKJRRFD:l/HXATFASQ4E2JBG434DUEN54EZZ:l/WUZC5WSTQTPJUJ4KFAYCUT5IPD:l/MZUEUOFHBNVTRCJYJEG7QY4VWT
|   |-- merged
|   `-- work
|-- cb40b5b47c699050305676b35b1cea1ce08b38604dd68243c4be48934125b1a3    // 第1层
|   |-- diff
|   |-- link    // WUZC5WSTQTPJUJ4KFAYCUT5IPD
|   |-- lower   // l/MZUEUOFHBNVTRCJYJEG7QY4VWT
|   |-- merged
|   `-- work
`-- l
    |-- 5PHT7S3MCZTTQOXVPA4CKJRRFD -> ../89f7a20dda3d868840e20d9e8f1bfe20c5cca51c27b07825f100da0f474672f6/diff
    |-- HXATFASQ4E2JBG434DUEN54EZZ -> ../783ad02709b67ac47b55198e9659c4592f0972334987ab97f42fd10f1784cbba/diff
    |-- MZUEUOFHBNVTRCJYJEG7QY4VWT -> ../664ae13f1c21402385076025d68476eb8d1cc4be6c6a218b24bd55217ac62672/diff
    |-- QMKHIPSDT4JTPE4FLT7QGJ33ND -> ../bad073a2d1f79a03af6caa0b3f51a22e6762cebbc0c30e45458fe6c1ff266f68/diff
    `-- WUZC5WSTQTPJUJ4KFAYCUT5IPD -> ../cb40b5b47c699050305676b35b1cea1ce08b38604dd68243c4be48934125b1a3/diff

l目录下为超链接，缩短后的目录，为了避免mount时超出页大小限制。

每一层中的diff文件夹包含实际内容。

每一层中都有一个link文件，内容为l目录中的超链接，超链接实际指向当前层目录中的diff文件夹。

除去最底层的目录外，其余每一层中包含一个lower文件，包含了该层的所有更底层名称和顺序，可以根据该文件构建出整个镜像的层次结构。

work目录用于OverlayFS内部使用。

最底层只有link文件，无lower文件，因此664ae13f1c21402385076025d68476eb8d1cc4be6c6a218b24bd55217ac62672为最底层。

以上五层为lower，只读。

当使用docker run -it ubuntu:latest /bin/bash启动一个容器后，在overlay2目录下会多出两个文件夹。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[root@localhost overlay2]# tree -L 1 0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08-init 0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08 l
0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08-init
|-- diff
|-- link    // ZJVMGTB2IOJ6QF57TYM5O7EWXW
|-- lower   // l/QMKHIPSDT4JTPE4FLT7QGJ33ND:l/5PHT7S3MCZTTQOXVPA4CKJRRFD:l/HXATFASQ4E2JBG434DUEN54EZZ:l/WUZC5WSTQTPJUJ4KFAYCUT5IPD:l/MZUEUOFHBNVTRCJYJEG7QY4VWT
|-- merged
`-- work
0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08
|-- diff
|-- link
|-- lower   // l/ZJVMGTB2IOJ6QF57TYM5O7EWXW:l/QMKHIPSDT4JTPE4FLT7QGJ33ND:l/5PHT7S3MCZTTQOXVPA4CKJRRFD:l/HXATFASQ4E2JBG434DUEN54EZZ:l/WUZC5WSTQTPJUJ4KFAYCUT5IPD:l/MZUEUOFHBNVTRCJYJEG7QY4VWT
|-- merged
`-- work
l
|-- 5PHT7S3MCZTTQOXVPA4CKJRRFD -> ../89f7a20dda3d868840e20d9e8f1bfe20c5cca51c27b07825f100da0f474672f6/diff
|-- AOLYGFOHIAHWU5CBAJFULNAXI7 -> ../0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08/diff
|-- HXATFASQ4E2JBG434DUEN54EZZ -> ../783ad02709b67ac47b55198e9659c4592f0972334987ab97f42fd10f1784cbba/diff
|-- MZUEUOFHBNVTRCJYJEG7QY4VWT -> ../664ae13f1c21402385076025d68476eb8d1cc4be6c6a218b24bd55217ac62672/diff
|-- QMKHIPSDT4JTPE4FLT7QGJ33ND -> ../bad073a2d1f79a03af6caa0b3f51a22e6762cebbc0c30e45458fe6c1ff266f68/diff
|-- WUZC5WSTQTPJUJ4KFAYCUT5IPD -> ../cb40b5b47c699050305676b35b1cea1ce08b38604dd68243c4be48934125b1a3/diff
`-- ZJVMGTB2IOJ6QF57TYM5O7EWXW -> ../0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08-init/diff

0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08-init用于存放容器初始化时的信息，通过下面查看更直观。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@localhost overlay2]# tree 0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08-init
0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08-init
|-- diff
|   |-- dev
|   |   `-- console
|   `-- etc
|       |-- hostname
|       |-- hosts
|       |-- mtab -> /proc/mounts
|       `-- resolv.conf
|-- link
|-- lower
|-- merged
`-- work
    `-- work

0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08的直接底层为init层，更详细的目录结构如下。

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
[root@localhost overlay2]# tree -L 2  0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08
0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08
|-- diff
|-- link
|-- lower
|-- merged
|   |-- bin
|   |-- boot
|   |-- dev
|   |-- etc
|   |-- home
|   |-- lib
|   |-- lib64
|   |-- media
|   |-- mnt
|   |-- opt
|   |-- proc
|   |-- root
|   |-- run
|   |-- sbin
|   |-- srv
|   |-- sys
|   |-- tmp
|   |-- usr
|   `-- var
`-- work
    `-- work

merged文件夹中内容较多，为overlay2的直接挂载点，对容器的修改会反应到该目录中。例如在容器中增加/root/hello.txt文件，在merged目录下会增加root/hello.txt文件。

1
2
3
[root@localhost overlay2]# mount  | grep overlay2
/dev/mapper/centos-root on /var/lib/docker/overlay2 type xfs (rw,relatime,attr2,inode64,noquota)
overlay on /var/lib/docker/overlay2/0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08/merged type overlay (rw,relatime,lowerdir=/var/lib/docker/overlay2/l/ZJVMGTB2IOJ6QF57TYM5O7EWXW:/var/lib/docker/overlay2/l/QMKHIPSDT4JTPE4FLT7QGJ33ND:/var/lib/docker/overlay2/l/5PHT7S3MCZTTQOXVPA4CKJRRFD:/var/lib/docker/overlay2/l/HXATFASQ4E2JBG434DUEN54EZZ:/var/lib/docker/overlay2/l/WUZC5WSTQTPJUJ4KFAYCUT5IPD:/var/lib/docker/overlay2/l/MZUEUOFHBNVTRCJYJEG7QY4VWT,upperdir=/var/lib/docker/overlay2/0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08/diff,workdir=/var/lib/docker/overlay2/0326c1da0af912a6ea5efda77b65b04e796993e0f111ed8f262c55b2716f1c08/work)

ref

Posted on Edited on

本文绝大多数题目来源于网络，部分题目为原创。

slice相关

以下代码有什么问题，说明原因

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type student struct {
	Name string
	Age  int
}

func pase_student() {
	m := make(map[string]*student)
	stus := []student{
		{Name: "zhou", Age: 24},
		{Name: "li", Age: 23},
		{Name: "wang", Age: 22},
	}
	for _, stu := range stus {
		m[stu.Name] = &stu
	}
}

每次遍历的时候stu变量为值拷贝，stu变量的地址未改变，即&stu未改变，遍历结束后stu指向stus中的最后一个元素。

使用reflect.TypeOf(str)打印出的类型为main.student，如果使用stu.Age += 10这样的语法是不会修改stus中的值的。

可修改为如下形式：

1
2
3
for i, _ := range stus {
    m[stus[i].Name] = &stus[i]
}

有一个slice of object, 遍历slice修改name为指定的值

1
2
3
4
5
6
7
8
type foo struct {
 name string
 value string
}

func mutate(s []foo, name string) {
// TODO
}

意在考察range遍历的时候是值拷贝，以及slice的内部数据结构，slice的数据结构如下：

1
2
3
4
5
6
struct    Slice
{    // must not move anything
    byte*    array;        // actual data
    uintgo    len;        // number of elements
    uintgo    cap;        // allocated number of elements
};

执行append函数后会返回一个新的Slice对象，新的Slice对象跟旧Slice对象共用相同的数据存储，但是len的值并不相同。

该题目中，可以通过下面的方式来修改值:

1
2
3
4
5
6
7
8
9
// range方式
for i, _ := range s {
	s[i].name = name
}

// for i形式
for i:=0; i<len(s); i++ {
  s[i].name = name
}

从slice中找到一个元素匹配name，并将该元素的指针添加到一个新的slice中，返回新slice

1
2
3
4
func find(s []foo, name string) []*foo {
// TODO

}

仍旧是考察range是值拷贝的用法，此处使用for i 循环即可

1
2
3
4
5
6
7
8
9
10
11
func find(s []foo, name string) []*foo {
	res := []*foo{}

	for i := 0; i < len(s); i++ {
		if s[i].name == name {
			res = append(res, &(s[i]))
			break
		}
	}
	return res
}

下面输出什么内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func m(s []int) {
	s[0] = -1
	s = append(s, 4)
}

func main() {
	s1 := []int{1, 2, 3}
	m(s1)
	s2 := make([]int, 3, 6)
	m(s2)
	s2 = append(s2, 7)
	s3 := [3]int{1, 2, 3}
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
}

slice的函数传递为值拷贝方式，在函数m中对下标为0的元素的修改会直接修改原slice中的值，因为slice中的指针指向的地址是相同的。

append之后的slice虽然可能是在原数组上增加了元素，但原slice中的len字段并没有变化。

make([]int, 3, 6)虽然指定了slice的cap，但对于append没有影响，还是会在slice中最后一个元素的下一个位置增加新元素。

数组由于是值拷贝，对新数组的修改不会影响到原数组。

输出内容如下：

1
2
3
[-1 2 3]
[-1 0 0 7]
[1 2 3]

下面输出什么内容

该题目为我自己想出来的，非来自于互联网，意在考察对slice和append函数的理解。

1
2
3
4
5
6
7
8
9
func f() {
	s1 := make([]int, 2, 8)
	fmt.Println(s1)
	s2 := append(s1, 4)
	fmt.Println(s2)
	s3 := append(s1, 5)
	fmt.Println(s3)
	fmt.Println(s2)
}

输出结果如下，在执行第二个append后，第一个append在内存中增加的元素4会被5覆盖掉。执行结果可以通过fmt.Println(s1, cap(s1), &s1[0])的形式将第一个元素的内存地址打印出来查看。

1
2
3
[0 0 4]
[0 0 5]
[0 0 5]

goroutine

以下代码输出内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
	"fmt"
	"runtime"
)

func main() {
	runtime.GOMAXPROCS(1)
	go func() {
		fmt.Println(1)
	}()
	for {
	}
	fmt.Println(1)
}

不会有任何输出

下面输出的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
type People struct{}

func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}

type Teacher struct {
    People
}

func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}

func main() {
    t := Teacher{}
    t.ShowA()
}

输出

1
2
showA
showB

有点出乎意料，可以举个反例，如果ShowA()方法会调用到Teacher类型的ShowB()方法，假设People和Teacher并不在同一个包中时，编译一定会出现错误。

Go中没有继承机制，只有组合机制。

下面代码会触发异常吗？请详细说明

1
2
3
4
5
6
7
8
9
10
11
12
13
func main() {
	runtime.GOMAXPROCS(1)
	int_chan := make(chan int, 1)
	string_chan := make(chan string, 1)
	int_chan <- 1
	string_chan <- "hello"
	select {
	case value := <-int_chan:
		fmt.Println(value)
	case value := <-string_chan:
		panic(value)
	}
}

会间歇性触发异常，select会随机选择。

以下代码能编译过去吗？为什么？

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
package main

import (
	"fmt"
)

type People interface {
	Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
	if think == "bitch" {
		talk = "You are a good boy"
	} else {
		talk = "hi"
	}
	return
}

func main() {
	var peo People = Student{}
	think := "bitch"
	fmt.Println(peo.Speak(think))
}

不能编译过去，提示Stduent does not implement People (Speak method has pointer receiver)，将Speak定义更改为func (stu Stduent) Speak(think string) (talk string)即可编译通过。

main的调用方式更改为如下也可以编译通过var peo People = new(Stduent)。

func (stu *Stduent) Speak(think string) (talk string)是*Student类型的方法，不是Stduent类型的方法。

下面输出什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
  "fmt"
  "time"
  "runtime"
)

func main() {
  runtime.GOMAXPROCS(1)
  arr := [10000]int{}
  for i:=0; i<len(arr); i++ {
    arr[i] = i
  }
  for _, a := range arr {
    go func() {
      fmt.Println(a)
    }()
  }
  for {
    time.Sleep(time.Second)
  }
}

一直输出9999.涉及到goroutine的切换时机，仅系统调用或者有函数调用的情况下才会切换goroutine，for循环情况下一直没有系统调用或函数切换发生，需要等到for循环结束后才会启动新的goroutine。

以下代码打印出来什么内容，说出为什么。。。

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
package main

import (
	"fmt"
)

type People interface {
	Show()
}

type Student struct{}

func (stu *Student) Show() {

}

func live() People {
	var stu *Student
	return stu
}

func main() {
	if live() == nil {
		fmt.Println("AAAAAAA")
	} else {
		fmt.Println("BBBBBBB")
	}
}

打印BBBBBBB。

byte与rune的关系

  • byte alias for uint8
  • rune alias for uint32，用来表示unicode
1
2
3
4
5
6
7
8
func main() {
    // range遍历为rune类型，输出int32
    for _, w:=range "123" {
        fmt.Printf("%T", w)
    }
    // 取数组为byte类型，输出uint8
    fmt.Printf("%T", "123"[0])
}

写出打印的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
type People struct {
	name string `json:"name"`
}

func main() {
	js := `{
		"name":"11"
	}`
	var p People
	p.name = "123"
	err := json.Unmarshal([]byte(js), &p)
	if err != nil {
		fmt.Println("err: ", err)
		return
	}
	fmt.Println("people: ", p)
}

打印结果为people: {123}

下面函数有什么问题？

1
2
3
func funcMui(x,y int)(sum int,error){
    return x+y,nil
}

函数返回值命名 在函数有多个返回值时，只要有一个返回值有指定命名，其他的也必须有命名。 如果返回值有有多个返回值必须加上括号； 如果只有一个返回值并且有命名也需要加上括号； 此处函数第一个返回值有sum名称，第二个为命名，所以错误。

以下函数输出什么

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
package main

func main() {
	println(DeferFunc1(1))
	println(DeferFunc2(1))
	println(DeferFunc3(1))
	println(DeferFunc4(1))
}

func DeferFunc1(i int) (t int) {
	t = i
	defer func() {
		t += 3
	}()
	return t
}

func DeferFunc2(i int) int {
	t := i
	defer func() {
		t += 3
	}()
	return t
}

func DeferFunc3(i int) (t int) {
	defer func() {
		t += i
	}()
	return 2
}

func DeferFunc4(i int) (t int) {
	t = 10
	return 2
}

输出结果为: 4 1 3 2

return语句不是一个原子指令，分为两个阶段，执行return后面的表达式和返回表达式的结果。defer函数在返回表达式之前执行。

  1. 执行return后的表达式给返回值赋值
  2. 调用defer函数
  3. 空的return

DeferFunc1在第一步执行表达式后t=1，执行defer后t=4，返回值为4

DeferFunc2在第一步执行表达式后t=1，执行defer后t=4，返回值为第一步表达式的结果1

DeferFunc3在第一步表达式为t=2，执行defer后t=3，返回值为t=3

DeferFunc4在第一步执行表达式后t=2，返回值为t=2

是否可以编译通过？如果通过，输出什么？

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
package main

import (
	"fmt"
)

func main() {
	sn1 := struct {
		age  int
		name string
	}{age: 11, name: "qq"}

	sn2 := struct {
		age  int
		name string
	}{age: 11, name: "qq"}

	sn3 := struct {
		name string
		age  int
	}{age: 11, name: "qq"}

	if sn1 == sn2 {
		fmt.Println("sn1 == sn2")
	}

	if sn1 == sn3 {
		fmt.Println("sn1 == sn3")
	}


	sm1 := struct {
		age int
		m   map[string]string
	}{age: 11, m: map[string]string{"a": "1"}}

	sm2 := struct {
		age int
		m   map[string]string
	}{age: 11, m: map[string]string{"a": "1"}}

	if sm1 == sm2 {
		fmt.Println("sm1 == sm2")
	}
}

结构体比较 进行结构体比较时候，只有相同类型的结构体才可以比较，结构体是否相同不但与属性类型个数有关，还与属性顺序相关。

还有一点需要注意的是结构体是相同的，但是结构体属性中有不可以比较的类型，如map,slice。 如果该结构属性都是可以比较的，那么就可以使用“==”进行比较操作。

是否可以编译通过？如果通过，输出什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
	"fmt"
)

func Foo(x interface{}) {
	if x == nil {
		fmt.Println("empty interface")
		return
	}
	fmt.Println("non-empty interface")
}

func main() {
	var x *int = nil
	Foo(x)
}

输出“non-empty interface”

交替打印数字和字母

使用两个 goroutine 交替打印序列，一个 goroutine 打印数字， 另外一个 goroutine 打印字母， 最终效果为: 12AB34CD56EF78GH910IJ1112KL1314MN1516OP1718QR1920ST2122UV2324WX2526YZ2728

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
package main

import (
	"fmt"
	"sync"
)


func main() {
	number, letter := make(chan bool), make(chan bool)
	wait := new(sync.WaitGroup)

	go func () {
		num := 1
		for {
			<-number
			fmt.Printf("%d%d", num, num+1)
			num += 2
			letter <- true
			if num > 28 {
				break
			}
		}
		wait.Done()
	}()

	go func () {
		begin := 'A'
		for {
			<- letter
			if begin < 'Z' {
				fmt.Printf("%c%c", begin, begin+1)
				begin+=2
				number <- true
			} else {
				break
			}
		}

		wait.Done()
	}()

	number <- true

	wait.Add(2)

	wait.Wait()
}

struct类型的方法调用

假设T类型的方法上接收器既有T类型的，又有T指针类型的，那么就不可以在不能寻址的T值上调用T接收器的方法。

请看代码,试问能正常编译通过吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import (
    "fmt"
)
type Lili struct{
    Name string
}
func (Lili *Lili) fmtPointer(){
    fmt.Println("poniter")
}
func (Lili Lili) fmtReference(){
    fmt.Println("reference")
}
func main(){
    li := Lili{}
    li.fmtPointer()
}

能正常编译通过，并输出”poniter”

请接着看以下的代码，试问能编译通过？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import (
    "fmt"
)
type Lili struct{
    Name string
}
func (Lili *Lili) fmtPointer(){
    fmt.Println("poniter")
}
func (Lili Lili) fmtReference(){
    fmt.Println("reference")
}
func main(){
    Lili{}.fmtPointer()
}

不能编译通过。
“cannot call pointer method on Lili literal”
“cannot take the address of Lili literal”

其实在第一个代码示例中，main主函数中的“li”是一个变量，li的虽然是类型Lili，但是li是可以寻址的，&li的类型是Lili，因此可以调用Lili的方法。

golang context包的用法

  1. goroutine之间的传值
  2. goroutine之间的控制

在单核cpu的情况下，下面输出什么内容？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
	"fmt"
	"sync"
)

func main() {
	wg := sync.WaitGroup{}
	for _, i:=range []int{1, 2, 3, 4, 5} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Println(i)
		} ()
	}
	wg.Wait()
}

考察golang的runtime机制，goroutine的切换时机只有在有系统调用或者函数调用时才会发生，本例子中的for循环结束之前不会发生goroutine的切换，所以最终输出结果为5.

下面输出什么

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
package main

import (
	"fmt"
)

type People interface {
	Speak(string) string
}

type Stduent struct{}

func (stu *Stduent) Speak(think string) (talk string) {
	if think == "bitch" {
		talk = "You are a good boy"
	} else {
		talk = "hi"
	}
	return
}

func main() {
	var peo People = Stduent{}
	think := "bitch"
	fmt.Println(peo.Speak(think))
}

编译不通过，仅*Student实现了People接口，更改为var peo People = &Student{}即可编译通过。

下面输出什么

1
2
3
4
5
6
7
8
9
10
package main

const cl = 100

var bl = 123

func main() {
	println(&bl, bl)
	println(&cl, cl)
}

编译失败，常量cl通常在预处理阶段会直接展开，无法取其地址。

以下代码是否存在问题，请解释你的判断和理由

1
2
3
4
5
6
7
8
import "sync"

func f(m sync.Mutex) {
   m.Lock()
   defer m.Unlock()

   // Do something...
}

Mutex对象不能被值拷贝,后续传递需要使用指针的形式

以下代码输出是什么 解释一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func    main()  {
    case1()
    case2()
}

func    case1() {
   s1   :=  make([]string,  1,  20)
   s1[0]    =   "hello"
   p1   :=  &s1[0]
   s1   =   append(s1,  "world")
   *p1  =   "hello2"
   fmt.Printf("value    of  p1  is  %s, value   of  s1[0]   is  %s  \n",    *p1,    s1[0])
}

func    case2() {
   s1   :=  make([]string)
   s1[0]    =   "hello"
   p1   :=  &s1[0]
   s1   =   append(s1,  "world")
   *p1  =   "hello2"
   fmt.Printf("value    of  p1  is  %s, value   of  s1[0]   is  %s  \n",    *p1,    s1[0])
}

本题意在考察string和slice的数据结构，string的数据结构如下：

http://research.swtch.com/godata2.png

case1的内存结构变化情况如下：

case2由于s1默认长度为0，直接使用s1[0]复制会出现panic错误。

ref

Posted on Edited on

通过使用Google的登陆二步验证（即Google Authenticator服务），我们在登陆时需要输入额外由手机客户端生成的一次性密码。大大提高登陆的安全性。

实现Google Authenticator功能需要服务器端和客户端的支持。服务器端负责密钥的生成、验证一次性密码是否正确。客户端记录密钥后生成一次性密码。

google实现了基于时间的TOTP算法（Time-based One-time Password），客户端实现包括了android和ios。

算法为公开算法，google没有提供服务端的实现，各个语言都有单独的实现。自己系统使用可以直接使用网上的代码。

linux下有libpam-google-authenticator模块，可以使用yum或者源码编译安装，github上有源码，编译出来的为so文件，可以加到sshd的配置文件中，用于给sshd提供二次认证机制。

客户端和服务端存在时间差的问题，google authenticator的超时时间为30s，服务端可以使用两个30s的时间来验证，包括当前和上一个30s。

Posted on Edited on

曾经使用多说和网易云评论作为博客的评论系统，不幸都相继倒闭后，博客就一直没有评论系统。虽博客的访问量可以忽略不计，但本着折腾和好奇的原则，还是折腾一下gitment。

更新hexo-theme-next主题

最新版本的next主题已经默认支持gitment，需要将next主题升级到最新版本。

我的hexo-theme-next使用单独的git项目进行管理，git地址为：https://github.com/kuring/hexo-theme-next。接下来需要将fork出来的git项目跟next的git项目进行同步。

  1. 在本地创建名字为upstream的remote，指向地址为：git remote add upstream https://github.com/theme-next/hexo-theme-next.git

  2. 拉取next项目到本地分支，本地的分支，执行git fetch upstream

  3. 将upsteam/master分支合并到master分支上

1
2
3
4
5
6
7
8
9
10
git checkout master

# 由于修改了_config.yml文件，存在冲突，合并失败
lvkai@osx:~/blog/kuring/themes/hexo-theme-next% git merge upstream/master                                                                                                128 ↵
Removing source/css/_common/components/third-party/gentie.styl
Removing layout/_third-party/comments/gentie.swig
Auto-merging _config.yml
CONFLICT (content): Merge conflict in _config.yml
Removing README.en.md
Automatic merge failed; fix conflicts and then commit the result.
  1. 解决冲突后提交并将master分支push到github仓库

注册gitment

前往：https://github.com/settings/profile

Developer settings -> Register a new application

在界面中输入如下内容：

image

获取到Client ID和Client Secret.

新建github repo

创建新的github项目：https://github.com/kuring/gitment-comments

在next主题中设置gitment

next主题的配置文件为theme/next/_config.yml，修改其中的gitment设置如下，

  1. client_id为在github中注册所获取到的client id
  2. client_secret为在github中注册所获取到的client secret
  3. github_repo为上面新创建的github repo名称
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Gitment
# Introduction: https://imsun.net/posts/gitment-introduction/
gitment:
  enable: true
  mint: true # RECOMMEND, A mint on Gitment, to support count, language and proxy_gateway
  count: true # Show comments count in post meta area
  lazy: false # Comments lazy loading with a button
  cleanly: false # Hide 'Powered by ...' on footer, and more
  language: # Force language, or auto switch by theme
  github_user: kuring # MUST HAVE, Your Github ID
  github_repo: gitment-comments # MUST HAVE, The repo you use to store Gitment comments
  client_id: xxx # MUST HAVE, Github client id for the Gitment
  client_secret: xxxx # EITHER this or proxy_gateway, Github access secret token for the Gitment
  proxy_gateway: # Address of api proxy, See: https://github.com/aimingoo/intersect
  redirect_protocol: # Protocol of redirect_uri with force_redirect_protocol when mint enabled

执行hexo clean && hexo g && hexo s重新生成页面并在本地运行，可以看到gitment组件已经可以显示了，但是提示Error: Comments Not Initialized错误，点击login，然后允许认证，即可消除该错误。

在界面上添加评论后，可以在github repo的issuse中看到，整个搭建完毕。

Posted on Edited on

概要

netfilter与iptables的关系

linux在内核中对数据包过滤和修改的模块为netfilter，netfilter模块本身并不对数据包进行过滤，只是允许将过滤数据包或修改数据包的函数hook到内核网络协议栈的适当位置。

iptables是用户态的工具，用于向netfilter中添加规则从而实现报文的过滤和修改等功能，工作在ip层。ebtables工作在数据链路层，用于处理以太网帧。

图中绿色代表iptables的表，可以看到有部分位于了数据链路层，之所以产生这种奇怪的架构，原因是bridge_nf模块，因为bridge工作在数据链路层，不一定会经过网络层，但仍然需要iptables的功能。详细信息可以在ebtables/iptables interaction on a Linux-based bridge中了解。

概念：tables -> chains -> rules

iptabels介绍

chain

每个表都由一组内置的链，还可以添加用户自定义链，只是用户自定义链没有钩子可以触发，需要从其他链通过-j即JUMP进行触发。

  • INPUT 链：发往本机的报文
  • OUTPUT 链：由本机发出的报文
  • FORWARD 链：经由本机转发的报文
  • PREROUTING 链：报文到达本机，进行路由决策之前
  • POSTROUTING 链：报文由本机发出，进行路由决策之后

image

从chain的角度考虑数据包的流向：

  • 到本机某进程的报文：PREROUTING -> INPUT
  • 由本机转发的报文：PREROUTING -> FORWARD -> POSTROUTING
  • 由本机某进程发出的报文：OUTPUT -> POSTROUTING

当一个网络包进入一台机器的时候，首先拿下 MAC 头看看，是不是我的。如果是，则拿下 IP 头来。得到目标 IP 之后呢，就开始进行路由判断。在路由判断之前，这个节点我们称为 PREROUTING。如果发现 IP 是我的，包就应该是我的，就发给上面的传输层，这个节点叫作 INPUT。如果发现 IP 不是我的，就需要转发出去，这个节点称为 FORWARD。如果是我的，上层处理完毕完毕后，一般会返回一个处理结果，这个处理结果会发出去，这个节点称为 OUTPUT，无论是 FORWARD 还是 OUTPUT，都是路由判断之后发生的，最后一个节点是 POSTROUTING。

table

有了chain的概念后，为了便于chain中rule的管理，又引入了table的概念，用于存放相同功能的rule，不同功能的rule放到不同的table中。

包括：filter nat mangle raw

filter

默认表，管理本机数据包的进出，用于实现包的过滤，对应内核模块iptables_filter

input：想要进入linux主机的包
output：linux主机要发送的包
forward：传递包到后端计算机，与nat table关联较多

nat

管理后端主机进出，与linux主机没有关系，与linux后的主机有关

prerouting：进行路由判断之前的规则(dnat/redirect)
postrouting：路由判断之后执行的规则(snat/masquerade)
output：与发出去的包有关

mangle

较少使用，用于拆解报文，修改数据包，并重新封装。

raw

raw表的主要作用是允许我们给某些特定的数据包打上标记。

rule

包含了匹配条件和处理动作。

匹配条件包括：source ip、destination ip、source port、destination port

处理动作包括：

  • accept: 将包交给协议栈
  • drop：直接丢弃数据包，不给任何回应
  • reject：拒绝数据包通过，并给一个响应信息，客户端会收到拒绝消息
  • queue: 交个某个用户态进程处理
  • dnat：目的地址转换
  • snat：源地址转换，必须要指定SNAT地址，即–to-source参数，可以是单个ip，也可以是网段。用在POSTROUTING链上。
  • masquerade: 源地址伪装，跟snat类似，不需要指定SNAT地址，会自动从服务器上获取SNAT的ip地址。如果有多个网卡的情况下，会使用路由选择算法。
  • mark: 对数据包进行打标签操作

table filter rule的关系

这三者之间的关系还是相当的绕。

链中的规则存在的表

chain中存放了rule，某些chain中注定不包含某些rule。例如prerouting链中的rule仅存在于nat raw mangle三张表中。

prerouting链中的规则存在的表：raw mangle nat
input链中的规则存在的表：mangle filter nat
forward链中的规则存在的表：mangle filter
output链中的规则存在的表：raw mangle filter nat
postrouting链中的规则存在的表：mangle nat

表中的规则可以被哪些链使用

raw表中的规则可以被链使用：prerouting output

image

表的名字为小写，链的名字为大写

常用操作

查询

iptables 查询默认的表为filter，默认会列出表中所有链的规则

  • -t 用于指定要操作的表，支持raw mangle filter nat，省略-t选项，默认使用filter表
  • -L 列出rule
  • -v 可查看更详细的信息
  • -n 规则中以ip地址的形式进行显示
  • –line-number 显示规则的编号
  • -x 包的计数以精确数字显示

iptables -t filter -L：从表的角度查询规则，用于查看filter表中的所有规则

iptables -L INPUT: 从链的角度查询规则，用于查看INPUT链中的所有规则

iptables -vL INPUT: 从链的角度查询规则，用于查看INPUT链中的所有规则，可查看更详细信息，包含了规则的匹配信息

iptables -nvL：以精确数字显示

修改

  • -F: 清空规则
  • -I: 表示插入规则
  • -A: 表示以追加的方式插入规则
  • --dport: 目的端口
  • --sport: 源端口
  • -s: 源ip
  • -d: 目的ip
  • --match-set：匹配ipset

iptables -F INPUT：清空filter表中的INPUT链中的所有规则。

删除

  • -D: 删除规则，iptables -D 链名 规则编号，其中规则编号可以通过--line-number查看到。
  • -F: 清空规则，iptables -F 链名 -t 表名
  • -X: 删除链 iptables -X 链名 -t 表名

trace

开启trace功能

1
2
3
4
5
# centos7 系统下有效，centos6下内核模块为ipt_LOG
$ modprobe nf_log_ipv4

# 用来验证module是否加载成功
$ sysctl net.netfilter.nf_log.2

要开启icmp协议的追踪，执行如下的命令

1
2
iptables -t raw -A OUTPUT -p icmp -m comment --comment "TRACE" -j TRACE
iptables -t raw -A PREROUTING -p icmp -m comment --comment "TRACE" -j TRACE

可以通过如下的命令看到插入的iptabels规则：

1
iptables -t raw -nvL --line-number

追踪日志最终会在/var/log/message或者/var/log/kern下看到：

1
Feb  6 11:22:04 c43k09006.cloud.k09.am17 kernel: TRACE: raw:PREROUTING:policy:3 IN=docker0 OUT= PHYSIN=bond0.9 MAC=02:42:30:fb:43:94:5c:c9:99:de:c4:8b:08:00 SRC=10.45.8.10 DST=10.45.4.99 LEN=84 TOS=0x00 PREC=0x00 TTL=62 ID=25550 DF PROTO=ICMP TYPE=0 CODE=0 ID=24191 SEQ=2

格式这块的含义如下：

“TRACE: tablename:chainname:type:rulenum “ where type can be “rule” for plain rule, “return” for implicit rule at the end of a user defined chain and “policy” for the policy of the built in chains.

环境清理，删除刚刚创建的规则即可，其中1为规则的编号：

1
2
3
4
5
# 可以通过此来查询之前创建的规则编号
iptables -t raw --line-number -nvL
# 删除规则
iptables -t raw -D PREROUTING 1
iptables -t raw -D OUTPUT 1

实战

试验1 基本规则管理

插入规则

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
# 清空filter表中的input链规则
[vagrant@localhost ~]$ sudo iptables -F INPUT

# 查看filter表中的详细规则，此时从其他机器上ping该ip是通的
[vagrant@localhost ~]$ sudo iptables -nvL INPUT
Chain INPUT (policy ACCEPT 7 packets, 388 bytes)
 pkts bytes target     prot opt in     out     source               destination
 
# 增加规则，拒绝192.168.33.1上的请求
# -I：表示插入
# INPUT为要插入的链
# -s：表示源ip地址
# -j：表示要执行的动作
[vagrant@localhost ~]$ sudo iptables -t filter -I INPUT -s 192.168.33.1 -j DROP

# 再次查询filter表中的规则，此时192.168.33.1上的报文已经不通
[vagrant@localhost ~]$ sudo iptables -t filter -nvL
Chain INPUT (policy ACCEPT 107 packets, 6170 bytes)
 pkts bytes target     prot opt in     out     source               destination
    0     0 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain OUTPUT (policy ACCEPT 56 packets, 4355 bytes)
 pkts bytes target     prot opt in     out     source               destination

# appent一条接收192.168.33.1的请求规则
[vagrant@localhost ~]$ sudo iptables -t filter -A INPUT -s 192.168.33.1 -j ACCEPT
# 新增加的序号为2，192.168.33.1的包匹配到1后就停止往下走，因此192.168.33.1还是ping不通当前主机
[vagrant@localhost ~]$ sudo iptables -nvL INPUT --line-number
Chain INPUT (policy ACCEPT 65 packets, 3572 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        9   756 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0
2        0     0 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0

# 插入一条ACCEPT rule，此时192.168.33.1可以ping通当前主机，新插入的规则优先
[vagrant@localhost ~]$ sudo iptables -t filter -I INPUT -s 192.168.33.1 -j ACCEPT
[vagrant@localhost ~]$ sudo iptables -nvL INPUT --line-number
Chain INPUT (policy ACCEPT 7 packets, 388 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0
2       10   840 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0
3        0     0 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0

# 新插入一条accept 192.168.33.2的规则，插入位置为2，可以看到插入到2的位置了
[vagrant@localhost ~]$ sudo iptables -t filter -I INPUT 2 -s 192.168.33.2 -j ACCEPT
[vagrant@localhost ~]$ sudo iptables -nvL INPUT --line-number
Chain INPUT (policy ACCEPT 7 packets, 388 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        1    84 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0
2        0     0 ACCEPT     all  --  *      *       192.168.33.2         0.0.0.0/0
3       10   840 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0
4        0     0 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0

删除规则

接下在上面实验的基础上测试删除规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 删除刚刚创建的规则2
[vagrant@localhost ~]$ sudo iptables -t filter -D INPUT 2
[vagrant@localhost ~]$ sudo iptables -nvL INPUT --line-number
Chain INPUT (policy ACCEPT 7 packets, 388 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        1    84 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0
2       10   840 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0
3        0     0 ACCEPT     all  --  *      *       192.168.33.1         0.0.0.0/0

# 删除source为192.168.33.1，动作为ACCEPT的规则，实际此时执行一次命令仅能删除一条
[vagrant@localhost ~]$ sudo iptables -t filter -D INPUT -s 192.168.33.1 -j ACCEPT
[vagrant@localhost ~]$ sudo iptables -nvL INPUT --line
Chain INPUT (policy ACCEPT 13 packets, 736 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1       11   936 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0

修改规则

在上面实验的基础上修改规则

1
2
3
4
5
6
7
8
9
10
# 将规则动作从REJECT更改为REJECT
[vagrant@localhost ~]$ sudo iptables -t filter -R INPUT 1 -s 192.168.33.1 -j REJECT
[vagrant@localhost ~]$ sudo iptables -nvL INPUT --line
Chain INPUT (policy ACCEPT 7 packets, 388 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 REJECT     all  --  *      *       192.168.33.1         0.0.0.0/0            reject-with icmp-port-unreachable

# 每个链都有一个默认规则，当前INPUT链中的默认为ACCEPT
# 以下可以修改INPUT链的默认规则为DROP，远程连接慎用，不要问我为什么
[vagrant@localhost ~]$ sudo iptables -t filter -P INPUT DROP

保存规则

防火墙的所有修改都是临时的，重启系统后会失效。iptables会读取/etc/sysconfig/iptables中的规则。

1
2
3
4
5
# iptables-save命令仅会打印当前的规则，需要使用重定向当前规则到文件中
[root@localhost system]# iptables-save > /etc/sysconfig/iptables

# 可以从规则文件中载入规则
[root@localhost system]# iptables-restore < /etc/sysconfig/iptables

实验二 各类匹配条件的使用

匹配条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 可一次性插入两条规则
[vagrant@localhost ~]$ sudo iptables -t filter -I INPUT -s 192.168.33.1,192.168.33.2 -j DROP
[vagrant@localhost ~]$ sudo iptables -t filter -nvL INPUT --line
Chain INPUT (policy ACCEPT 31 packets, 1744 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 DROP       all  --  *      *       192.168.33.2         0.0.0.0/0
2        0     0 DROP       all  --  *      *       192.168.33.1         0.0.0.0/0

# 可指定ip网段
[vagrant@localhost ~]$ sudo iptables -t filter -F INPUT
[vagrant@localhost ~]$ sudo iptables -t filter -I INPUT -s 192.168.33.0/24 -j DROP
[vagrant@localhost ~]$ sudo iptables -t filter -nvL INPUT --line
Chain INPUT (policy ACCEPT 7 packets, 388 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 DROP       all  --  *      *       192.168.33.0/24      0.0.0.0/0

[vagrant@localhost ~]$ sudo iptables -t filter -I INPUT ! -s 192.168.33.0/24 -j DROP
[vagrant@localhost ~]$ sudo iptables -t filter -nvL INPUT --line
Chain INPUT (policy ACCEPT 19 packets, 1048 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 DROP       all  --  *      *      !10.0.2.0/24          0.0.0.0/0

协议类型

使用-p来指定协议类型，支持tcp udp icmp等，不指定时默认匹配所有协议

网卡接口

-i来指定从某个网卡进入的流量，仅使用于PREROUTING INPUT FORWARD三条链。

-o来指定从某个网络流出的流量，仅适用于FORWARD OUTPUT POSTROUTING三条链。

实验三 扩展模块

端口

使用了扩展模块tcp udp，默认可以省略

--dport来匹配报文的目的端口，使用时必须指定协议，即-p选项。
--sport来匹配报文的源端口，使用时必须指定协议，即-p选项。

端口可以指定范围，例如22:25表示22-25之间的所有端口，22,25表示22和25端口，还可以配合起来使用，比如22,80:88表示22和80-88之间的端口。

1
2
3
4
5
6
# 可以指定目的端口的范围
[root@localhost vagrant]# iptables -t filter -I INPUT -s 192.168.33.1 -p tcp --dport 22:25 -j REJECT
[root@localhost vagrant]# iptables -t filter -nvL INPUT --line
Chain INPUT (policy ACCEPT 70 packets, 4024 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 REJECT     tcp  --  *      *       192.168.33.1         0.0.0.0/0            tcp dpts:22:25 reject-with icmp-port-unreachable

iprange扩展模块

iprange扩展模块可以指定一段连续的ip地址范围。

--src-range和--dst-range用来指定源地址和目的范围。

1
2
3
4
5
[root@localhost vagrant]# iptables -t filter -I INPUT -m iprange --src-range 192.168.33.1-192.168.33.10 -j DROP
[root@localhost vagrant]# iptables -t filter -nvL INPUT --line
Chain INPUT (policy ACCEPT 17 packets, 968 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 DROP       all  --  *      *       0.0.0.0/0            0.0.0.0/0            source IP range 192.168.33.1-192.168.33.10

string扩展模块

匹配报文中包含的字符串

1
2
3
4
5
6
# 匹配报文中包含XXOO的报文
[root@localhost vagrant]# iptables -t filter -I INPUT -m string --algo bm --string "XXOO" -j REJECT
[root@localhost vagrant]# iptables -t filter -nvL INPUT --line
Chain INPUT (policy ACCEPT 15 packets, 852 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 REJECT     all  --  *      *       0.0.0.0/0            0.0.0.0/0            STRING match  "XXOO" ALGO name bm TO 65535 reject-with icmp-port-unreachable

其他扩展

time扩展用来根据时间段进行匹配

connlimit用来对ip的并发连接数进行限制

limit模块限制单位时间内进出包的数量

tcp扩展中可以使用--tcp-flags可根据tcp flag进行匹配

state扩展可根据tcp的连接状态进行匹配

实验四 自定义链

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
# 创建自定义链 IN_WEB
[root@localhost vagrant]# iptables -t filter -N IN_WEB
[root@localhost vagrant]# iptables -nvL
Chain INPUT (policy ACCEPT 31 packets, 1780 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain OUTPUT (policy ACCEPT 16 packets, 1216 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain IN_WEB (0 references)
 pkts bytes target     prot opt in     out     source               destination
 
[root@localhost vagrant]# iptables -t filter -I IN_WEB -s 192.168.33.1 -j REJECT
[root@localhost vagrant]# iptables -t filter -I IN_WEB -s 192.168.33.2 -j REJECT

[root@localhost vagrant]# iptables -t filter -nvL IN_WEB --line
Chain IN_WEB (0 references)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 REJECT     all  --  *      *       192.168.33.2         0.0.0.0/0            reject-with icmp-port-unreachable
2        0     0 REJECT     all  --  *      *       192.168.33.1         0.0.0.0/0            reject-with icmp-port-unreachable

# 将IN_WEB自定义链添加到INPUT链上
[root@localhost vagrant]# iptables -t filter -I INPUT -p tcp --dport 80 -j IN_WEB
# 可以看到INPUT链中多出了IN_WEB链
[root@localhost vagrant]# iptables -nvL
Chain INPUT (policy ACCEPT 35 packets, 2012 bytes)
 pkts bytes target     prot opt in     out     source               destination
    0     0 IN_WEB     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0            tcp dpt:80

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain OUTPUT (policy ACCEPT 18 packets, 1408 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain IN_WEB (1 references)
 pkts bytes target     prot opt in     out     source               destination
    0     0 REJECT     all  --  *      *       192.168.33.2         0.0.0.0/0            reject-with icmp-port-unreachable
    0     0 REJECT     all  --  *      *       192.168.33.1         0.0.0.0/0            reject-with icmp-port-unreachable

# 重新定义自定链名字    
[root@localhost vagrant]# iptables -E IN_WEB WEB
[root@localhost vagrant]# iptables -nvL
Chain INPUT (policy ACCEPT 39 packets, 2244 bytes)
 pkts bytes target     prot opt in     out     source               destination
    0     0 WEB        tcp  --  *      *       0.0.0.0/0            0.0.0.0/0            tcp dpt:80

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain OUTPUT (policy ACCEPT 20 packets, 1520 bytes)
 pkts bytes target     prot opt in     out     source               destination

Chain WEB (1 references)
 pkts bytes target     prot opt in     out     source               destination
    0     0 REJECT     all  --  *      *       192.168.33.2         0.0.0.0/0            reject-with icmp-port-unreachable
    0     0 REJECT     all  --  *      *       192.168.33.1         0.0.0.0/0            reject-with icmp-port-unreachable
    
# 由于iptables有自定义链，不能删除
[root@localhost vagrant]# iptables -X WEB
iptables: Too many links.
# 将INPUT链引用的WEB链删除
[root@localhost vagrant]# iptables -D INPUT 1
# 此时仍不能删除自定义链，因为自定义链删除，需要上面没有任何规则
[root@localhost vagrant]# iptables -X WEB
iptables: Directory not empty.

# 先清空自定义链的规则后可以删除
[root@localhost vagrant]# iptables -F WEB
[root@localhost vagrant]# iptables -X WEB

ref

Posted on Edited on

为了其他主机可访问docker registry，必须采用https协议。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
registry_data_dir=~/docker_registry/data
cert_dir=~/docker_registry/certs
signdomain=mycert

# 制作证书
mkdir -p ${cert_dir}
openssl req -nodes -subj "/C=CN/ST=BeiJing/L=BeiJing/CN=$signdomain" -newkey rsa:4096 -keyout ${cert_dir}/$signdomain.key -out ${cert_dir}/${signdomain}.csr
openssl x509 -req -days 3650 -in ${cert_dir}/$signdomain.csr -signkey ${cert_dir}/${signdomain}.key -out ${cert_dir}/$signdomain.crt

# 从docker hub拉取registry镜像，并启动镜像
mkdir -p ${registry_data_dir}
docker run -d -p 15000:5000 --restart=always --name registry \
  -v ${registry_data_dir}:/var/lib/registry \
  -v ${cert_dir}:/certs \
  -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/${signdomain}.crt \
  -e REGISTRY_HTTP_TLS_KEY=/certs/${signdomain}.key \
  registry:2

停止registry镜像并删除的命令为：

1
docker stop registry && docker rm -v registry

下载最新的centos7镜像

1
docker pull centos:7.3.1611

将centos7镜像增加tag

1
2
3
4
5
6
7
8
docker tag centos:7.3.1611 127.0.0.1:15000/centos:7.3

# 可以看到列表中会多出一个镜像
[root@103-17-184-lg-201-k08 data]# docker images
REPOSITORY                                     TAG                 IMAGE ID            CREATED             SIZE
docker.io/registry                             2                   047218491f8c        4 weeks ago         33.17 MB
103-17-184-lg-201-k08.yidian.com:5000/centos   7.3                 67591570dd29        3 months ago        191.8 MB
docker.io/centos                               7.3.1611            67591570dd29        3 months ago        191.8 MB

docker push命令仅支持https协议，签名已经启动了自签名的https协议的registry，为了能够让docker能够信任registry，需要在/etc/docker/certs.d/目录下增加相应的crt文件，增加后的目录结构为/etc/docker/certs.d/103-17-184-lg-201-k08.yidian.com:5000/103-17-184-lg-201-k08.yidian.com.crt，添加完成后需要重启docker服务。

将image push到registry

1
docker push 103-17-184-lg-201-k08.yidian.com:5000/centos:7.3

api

可以直接通过curl命令来访问api：curl --cacert 103-17-184-lg-201-k08.yidian.com.crt -v https://103-17-184-lg-201-k08.yidian.com:5000/v2

ref

Posted on Edited on

某些情况下需要搭建自己的yum源，比如维持特定的软件包版本等，只需要从网上下载合适的rpm包，即可构建yum源。

repodata数据

创建/data/yum.repo目录用来存放rpm包。

可以使用yumdownloader命令来下载rpm包到本地，并且不安装。这里以安装mesos为例，在/data/yum.repo目录下执行yumdownloader mesos即可下载mesos的rpm包到本地。

安装createrepo：yum install createrepo，用来根据rpm包产生对应的包信息。

每加入一个rpm包需要更新下repo的信息，执行createrepo --update /data/yum.repo。会自动产生repodata目录。

搭建web服务

需要对外提供web服务，通常会使用nginx或者apache来对外提供服务，这里使用python SimpleHTTPServer来对外提供服务，执行cd /data/yum.repo && python -m SimpleHTTPServer 1080。

客户端的repo文件设置

安装yum优先级插件，用来设置yum源的优先级: yum install -y yum-plugin-priorities

每个需要使用该yum源的客户端需要在/etc/yum.repo.d/目录下增加devops.repo文件。

1
2
3
4
5
6
[devops]
name=dev-ops
baseurl=http://10.103.17.184:1080/
enabled=1
gpgcheck=0
priority=1

Posted on Edited on

本次grafana的升级从版本3.1.1，变更为4.4.3，涉及到一个大的版本跨度。同时之前在使用的存储为sqlite，趁着这次升级更改为mysql。

grafana升级

直接从官网下载对应的4.4.3版本的二进制包，修改部分配置即可，该部分没任何难度。

sqlite to mysql

由于grafana使用的表结构在3.1.1到4.4.3之间有变更，不能直接将3.1.1版本的sqlite中的数据导入到4.4.3的mysql中。我的方法为先使用3.1.1版grafana将数据从sqlite导入到mysql中，然后再升级grafana的版本，grafana可以自动修改表结构。

在的mysql中创建grafana的数据库，并修改数据库的编码为utf-8.

修改grafana 3.1.1配置文件conf/defaults.ini如下：

1
2
3
4
5
6
7
8
9
10
11
[database]
# You can configure the database connection by specifying type, host, name, user and password
# as separate properties or as on string using the url property.

# Either "mysql", "postgres" or "sqlite3", it's your choice
type = mysql
host = xx.xx.xx.xx:3306
name = grafana
user = dev
# If the password contains # or ; you have to wrap it with triple quotes. Ex """#password;"""
password = dev

启动grafana后会自动在grafana数据库中创建相应的表结构，接下来就是将sqlite中的数据导入到mysql中。

在data目录下增加如下脚本sqlitedump.sh，并执行sh sqlitedump.sh grafana.db > grafana.sql。

1
2
3
4
5
6
7
8
9
#!/bin/sh
DB=$1
TABLES=$(sqlite3 $DB .tables | grep -v migration_log)
for t in $TABLES; do
    echo "TRUNCATE TABLE $t;"
done
for t in $TABLES; do
    echo -e ".mode insert $t\nselect * from $t;"
done | sqlite3 $DB

然后将grafana.sql导入到新创建的mysql。

将grafana 3.1.1版本停掉，将grafana 4.4.3版本的配置指向到mysql数据库，启动grafana 4.4.3后，mysql中的表结构会自动变更。

至此，grafana的升级完成。

Posted on Edited on

由于不允许通过ssh直接连接服务器，即服务器的22端口是不开放的，但是其他端口号可以访问。这就造成了往服务器上传输文件会特别麻烦，需要通过relay中转一下。

rsync命令有shell模式和daemon模式，为了解决该问题，可以通过rsync的daemon模式，rysnc的daemon模式会默认使用873端口，不使用ssh协议，以此来绕过ssh的22端口限制。

最终可以实现在本地通过rsync一条命令直接同步文件或文件夹到服务器的指定目录下。

首先在服务器上搭建rsync的服务端，rsync的安装不再介绍。

修改服务器的rsync配置文件/etc/rsyncd.conf如下：

1
2
3
4
5
6
[worker]
path = /home/worker
list = true
uid = worker
gid = worker
read only = false

这里为了简便，并未设置rsync的用户名和密码。

客户端同步文件的命令如下：

1
rsync -avz $SRC worker@$HOST::worker --exclude=target --exclude=.git --exclude=.idea --delete

命令中的第一个worker为HOST的登录用户名，第二个worker为rysncd配置文件中配置的组名。–exclude选项可以用来屏蔽需要同步的文件夹。–delete选项用来同步删除的文件或文件夹。

daemon模式跟ssh模式相比，无法指定服务器的具体某一个路径，使用不够灵活，但也基本可以满足需求。只能通过daemon配置文件中配置的组中的path参数，同步时仅能通过::组名的形式来指定。

0%