概述

如何做好运维工作呢？ 首先需要对运维工作做一个全面的分析和理解。 只有这样，才能站在一定的高度，站在全局来管理这部分工作，从而使得方方面面的事情得以完整的展开，而不出问题。

运维工作的作用： 运维工作在所有工作中是什么样的地位， 它与其他工作是一个怎样的关系， 站在运维的角度上来说， 需要怎样做才算是到位。

运维工作的性质：

运维工作的重点：

总的工作方针

事情需要靠人来推动， 在工作的过程中， 人是事情的核心， 因此管理工作非常重要， 人的组织和安排， 培训和培养， 需要重视。

一、目标与任务

1、 快速部署： 新的设备，新的服务部署
2、 性能监控： 性能监控，报警
3、 异常处理： 异常问题的分析处理经验，流程
4、 日志分析： 日志是正常采集的， 可以被分析的
5、 数据备份： 数据是有备份的
6、 安全防护： 服务器是安全的

二、计划与安排

战略上， 需要做好整体的架构与安排
战略上， 有哪些新的工具可以为我所用
战略上， 整个系统有哪些地方可以进行优化
战略上， 有哪些新的技术需要学习

战术上， 一个任务，应该怎样完成， 需要分析
战术上， 需要完善文档， 如作业指导书， 资源地图...
战术上， 需要指定具体的计划与安排
战术上， 需要有服务器操作规范： 重要的操作，双重确认。 经常需要修改的配置文件要进行版本管理

三、落实，反馈，检查

• 做什么事情， 怎样算完成， 需要有标准
• 事情完成， 需要上级检查， 需要有反馈
• 遇到问题， 需要及时汇报

四、 总结与反思

• 定期总结自己的工作， 修正错误， 提高管理的效果。
• 对于错误要认真总结反思， 避免再次犯错。

思想延伸

发现可以使用工业生产中 全面质量管理 的做法，

人们不应仅仅把TQC看作是控制质量的活动， 它还可以通过不断改善各个方面的工作，而被作为企业提升竞争力和赢利潜能的发展战略。 TQC 中的“Q”意味着质量——优先权，同时也包含了成本和交货期的控制目标。 “T”代表“全面、全员”，也就是说企业内的全部员工包括自上而下从企业最高领导到中层领导，直至生产线操作工人都要参与进来。另外，供应商、代理商和销售商也都加入。“T”还表示高质量的管理（Top—management），它要求企业的高层领导对企业内实施 TQC 的成功负有管理的责任和义务。 “C”代表控制（Control），也就是对过程的控制。借助于TQC人们可以弄清过程的本质，监控并不断完善它，这样以取得成功的改善。

持续改进思想的特点：

1、长远的和持续的,平和的，但不显著
2、许多的小幅度
3、连续的和增量的
4、逐步的和稳定的
5、涉及每一个人
6、集体主义、团队奋斗和系统方法
7、传统的诀窍和达到最新的技术发展水平的目标
8、维护和改进
9、强调较小的投资，但非常努力维持
10、向人员倾斜
11、争取更好结果（能力）的过程
12、对慢速增长的经济有效

原则

• 丢掉对工艺原有的僵化的看法
• 考虑怎样可以做事情，而不是找出不做的理由
• 不找借口，对现有方法质疑
• 不要追求完美，马上付诸实施，尽管只达到约定目标的5%
• 立即纠正错误
• 排除障碍，寻找解决方法
• 问上五次“为什么？”，并寻找真正的原因
• 集合大家的意见而不仅仅是个别人的主意

爬虫是数据搜集系统中的一个重要工具，主要用于从Web上搜集数据。一般一个爬虫的流程如下：

func Crawler(seed_url):

Q = Queue()
Q.append(seed_url)
while !Q.empty() :
    link = Q.pop()
    html = download(link)
    sub_links = extract_links(html)
    for link in sub_links:
        Q.append(link)

如果我们要设计一个分布式爬虫，可以将上述程序分成3个部分：

downloader : 输入一个url，返回这个url对应的HTML
link extractor : 输入一个HTML，返回这个HTML中的链接
redirector : 负责接收link extractor提取的链接，并且将这些链接转发给downloader

不过，因为downloader主要消耗网络资源，而link extractor主要消耗CPU资源，因此我们可以将1，2部分合并在一个程序中。我们把合并后的程序也称为downloader。downloader集群通过nginx做负载均衡和外面通信。而downloader集群的鲁棒性可以通过nginx的health check实现。
Downloader

downloader的任务就是 1. 给定一个url，将他对应的HTML下载下来，写到磁盘上 2. 从HTML中提取链接，并将提取出来的链接发送给redirector

下载网页这一步是需要解决一下的问题： 1. 如何通过HTTP GET下载网页（这个是最简单的） 2. 如何使用HTTP 代理 3. 如何通过HTTP POST下载网页，这个涉及到表单的自动post 4. 如何处理页面的Javascript，获得Ajax的调用内容 5. 如何处理非HTML网页，比如PDF，Excel等等
Redirector

redirector的任务是 1. 控制每个不同网站的爬取速率 2. 控制网站爬取的优先级 3. 控制网页的更新速率（同一个网页，什么时候再爬一次）

所以，redirector从downloader接受到新的链接后，要对链接进行排序，整理，再发送给downloader下载。从而redirector和downloader之间形成闭环。
Golang

golang在实现上述逻辑时，可以充分发挥它强大的channel特性。

比如，如何控制不同网站的爬取速率？

可以给每个域名建立一个channel，每个域名的网页都进入到各自的channel。然后channel的消费者按照一定的速率从channel中取出链接进行消费。

不过使用channel也有一个问题。就是channel是阻塞的，如果channel满了，一定要消费者消费一个才能往里面放东西。而因为我们整个系统是一个环状系统：

downloader 有一个input的queue A
redirector 有一个input的queue B
redirector将B中的链接放入A
download消费A中的链接，得到新链接，放入到B

这时候，如果A，B都满了，redirector和downloader就会出现死锁，因为他们都需要别人先动一下，自己才能动。

因此，我们就需要设计一个逻辑，让所有的queue都不可能满。这样就只能利用文件系统了。

如果queue满了，将链接写文件
如果queue没有满，将链接写入queue中
如果queue空闲了，将文件中的链接写入queue

管道(Channel)是Go语言中比较重要的部分，经常在Go中的并发中使用。今天尝试对Go语言的管道来做以下总结。总结的形式采用问答式的方法，让答案更有目的性。

Q1.管道是什么？
管道是Go语言在语言级别上提供的goroutine间的通讯方式，我们可以使用channel在多个goroutine之间传递消息。channel是进程内的通讯方式，是不支持跨进程通信的，如果需要进程间通讯的话，可以使用Socket等网络方式。

以上是管道的概念，下面我们就看下管道的语法。

Q2.管道的语法?

整个Go语言的语法都比较简洁，管道也不例外，其语法如下所示：

在此应当注意，管道是类型相关的，即一个管道只能传递一种类型的值。管道中的数据是先进先出的。

 1 // 声明方式，在此ElemType是指此管道所传递的类型
 2 var chanName chan ElemType
 3 // 声明一个传递类型为int的管道
 4 var ch chan int
 5 // 声明一个map，元素是bool型的channel
 6 var m map[string] chan bool
 7 
 8 // 定义语法,定义需要使用内置函数make()即可，下面这行代码是声明+定义一个整型管道
 9 ch := make(chan int)
10 // 事先定义好管道的size,下面这行代码定义管道的size为100
11 ch := make(chan int, 100)
12 
13 // 由管道中读写数据，<-操作符是与最左边的chan优先结合的
14 // 向管道中写入一个数据，在此需要注意：向管道中写入数据通常会导致程序阻塞,直到有
15 // 其他goroutine从这个管道中读取数据
16 ch<- value
17 // 读取数据，注意：如果管道中没有数据，那么从管道中读取数据会导致程序阻塞，直到有数据
18 value := <-ch
19 
20 // 单向管道
21 var ch1 chan<- float64     // 只能向里面写入float64的数据，不能读取
22 var ch2 <-chan int         // 只能读取int型数据
23 
24 // 关闭channel，直接调用close()即可
25 close(ch)
26 // 判断ch是否关闭，判断ok的值，如果是false,则说明已经关闭(关闭的话读取是不会阻塞的)
27 x, ok := <-ch

Q3.管道的使用场景?

在第一个问题中，我们已经知道管道可以做进程间通讯，Go中自带了对协程的支持(关键字go)，而管道就是各个协程间通讯的一个方法。这里我们举些简单的小例子来说明一下管道如何在协程中使用。

 1 package main
 2 import "fmt"
 3 
 4 func print() {
 5     fmt.Println("Hello world")
 6 }
 7 
 8 func main() {
 9     for i := 0; i < 10; i++ {
10         go print()
11     }
12 }

上面的代码意思大致是：使用协程来并行输出10次 "Hello world", 但是大家运行上面代码的时候，会发现不会有输出。这是因为虽然使用go关键字进行了协程的创建，但是还没有等到执行的时候，main函数已经退出来了，进程已经关闭，所以起来的协程也不会被执行。

如果你有C相关的多线程经验时，可已经将协程改为线程，之后调用线程的join方法，让主线程等待子线程执行完毕后再退出。而在Go语言中，我们可以利用管道的写入阻塞和读取阻塞来完成类似线程join的行为。代码如下所示：

 1 package main
 2 import "fmt"
 3 
 4 func print(ch chan int) {
 5     fmt.Println("Hello world")
 6     ch<- 1
 7 }
 8 
 9 func main() {
10     chs := make([]chan int)
11     for i := 0; i < 10; i++ {
12         chs[i] = make(chan int)
13         go print(chs[i])
14     }
15     
16     for _, ch := range(chs){
17         <-ch
18     }
19 }

通过以上代码，我们就可以完成了并行输出10此Hello world 的效果。

有一个问题留给大家，如果将 print改为

func print(ch chan int){
     ch<- 1
     fmt.Println("Hello world")
}

会打印出什么呢？

由于水平有限，难免会有错误，请大家指正。
谢谢。

Channel是什么

在Go语言中,Channel即指通道类型。有时也用它来直接指代可以传递某种类型的值的通道。

类型表示法

chan T

关键字chan代表了通道类型的关键字，T则代表了该通道类型的元素类型。

例如：type IntChan chan int 别名类型IntChan代表了元素类型为int的通道类型。我们可以直接声明一个chan int类型的变量：var IntChan chan int,在被初始化后，变量IntChan就可以被用来传递int类型的元素值了。

chan<- T

只能被用来发送值, <-表示发送操作符

<-chan T

接收通道值, <-表示接收操作符

值表示法

属性和基本操作

• 基于通道的通讯是在多个Goroutine之间进行同步的重要手段。而针对通道的操作本身也是同步的。
• 在同一时刻，仅有一个Goroutine能向一个通道发送元素值
• 同时也仅有一个Goroutine能从它那里接收元素值。
• 通道相当于一个FIFO先进先出的消息队列。
• 通道中的元素值都具有原子性。它们是不可被分割的。通道中的每一个元素都只可能被某一个Goroutine接收。已被接收的元素值会立刻被从通道中删除。

初始化通道

make(chan int, 10)

~ 表达式初始化了一个通道类型的值。传递给make函数的第一个参数表明此值的具体类型是元素类型为int的通道类型，而第二个参数则指该值在同一时刻最多可以容纳10个元素值。

package main
import (
    "fmt"
)

type Person struct {
    Name string
    Age  uint8
    Address Addr
}

type Addr struct{
    city string
    district string
}

func main(){
    persionChan := make(chan Person,1)

    p1 := Person{"Harry",32,Addr{"Shanxi","Xian"}}
    fmt.Printf("P1 (1): %v\n",p1)

    persionChan <- p1

    p1.Address.district = "shijingshan"
    fmt.Printf("P2 (2): %v\n",p1)

    p1_copy := <-persionChan
    fmt.Printf("p1_copy: %v\n",p1_copy)
}

go test.go 运行结果

P1 (1): {Harry 32 {Shanxi Xian}}
P2 (2): {Harry 32 {Shanxi shijingshan}}
p1_copy: {Harry 32 {Shanxi Xian}}

通道中的元素值丝毫没有受到外界的影响。这说明了，在发送过程中进行的元素值属于完全复制。这也保证了我们使用通道传递的值的不变性。

关闭通道

close(strChan)

我们应该先明确一点：无论怎么样都不应该在接收端关闭通道。因为在那里我们无法判断发送端是否还会向该通道发送元素值。

package main

import (
    "fmt"
    "time"
)

func main(){
    ch := make(chan int, 5)
    sign := make(chan int, 2)

    go func() {
        for i :=0;i<5;i++ {
            ch <- i
            time.Sleep(1 * time.Second)
        }
        close(ch)
        fmt.Println("The channel is closed.")
        sign <- 0
    }()

    go func() {
        for {
            e, ok := <-ch
            fmt.Printf("%d (%v)\n", e,ok)
            if !ok {
                break
            }
            time.Sleep(2 * time.Second)
        }
        fmt.Println("Done.")
        sign <- 1
    }()
    <- sign
    <- sign
}

    运行结果：
    0 (true)
    1 (true)
    2 (true)
    The channel is closed.
    3 (true)
    4 (true)
    0 (false)
    Done.

运行时系统并没有在通道ch被关闭之后立即把false作为相应接收操作的第二个结果，而是等到接收端把已在通道中的所有元素值都接收到之后才这样做。这确保了在发送端关闭通道的安全性。

爬虫系统的要求

基本要求

• 遍历链接，并获取网页
• 网页解析，分析
• 数据存储
• 日志： 错误日志， 运行日志

分布式要求

• 并行爬取： 效率高， 可以设定爬虫的数目
• 任务管理： 任务队列， 出错了可以重新爬取
• 代理： 考虑到爬取太多，可能会触发拦截，因此需要通过代理。
• 策略： 可以灵活的设定策略， 爬取频率， 爬取数量， 使用不同的网管，使用不同的header

爬虫管理

• 不同的网站，爬虫的规则是不一样的，因此爬虫可以自定义规则
• 脚本： 有些网站可能需要登录认证。

循序渐进

v0.1 http请求

    baseUrl := "http://www.xxx.cn"
    req,_  := http.NewRequest("GET",baseUrl,nil)
    req.Header.Set("User-Agent", GetRandomUserAgent())
    client := http.DefaultClient
    res, e := client.Do(req)

    if e !=nil {
        fmt.Print(e)
        return
    }

    if res.StatusCode == 200 {
        body := res.Body
        defer body.Close()
        bodyByte,_ := ioutil.ReadAll(body)
        resStr := string(bodyByte)
        print(resStr)
    }