入职微软之后，这边大多数是使用 Windows 进行开发的，比如我的台式机是 Windows 的，还有一部分服务器是 Windows 的，当然 Linux 是也非常多。 很多情况下我是使用自己的 Mac 笔记本来远程连接我的 Windows 机器来开发的。比如如果我在工位上，我会用我的 Mac 连接两块显示屏，然后一种一块用来远程桌面连接我的 Windows 开发机，这样另外一块屏幕和 Mac 自带的屏幕就用来看文档或者使用 Teams 通讯等等。如果我回家了，我家里也是有两块屏，开上 VPN，照样用一块屏使用远程桌面，另外一块屏幕和 Mac 自带屏幕就可以做其他事情了。 这样就解决了一个问题：我的 Windows 基本上都是仅用作开发的，一块屏幕就开着一个 Visual Studio，其他的操作都会在 Mac 进行，比如查文档，发消息等等。这样我下班之后照样使用远程连接的方式来操作，和在公司就是一样的。这样就避免了一些软件的来回登录，比如如果我上班只用公司机器，下班了之后换了 Mac 还得切 Teams、切微信、切浏览器等等，还是很麻烦的，而且上班期间 Mac 就闲置了也不好。所以我就采取了这样的开发方案。

需求分析

有了这个情景，就引入了一个问题。开了一个远程桌面之后，我几乎一个屏幕都是被 Visual Studio 占据的，而远程桌面貌似只能开一个屏幕？如果我要再开一个终端窗口的话，那可能屏幕就不太够用了，或者它就得覆盖我的全屏 Visual Stuido。 另外我平时 Mac 终端软件都是使用 SSH 的，基本都是用来连 Linux 的，Windows 一般都是开远程桌面。但命令行这个情形的确让我头疼，让我感到不够爽，因为毕竟远程桌面之后，Windows 里面的操作都得挤在一个桌面里面操作了。当然可能能设置多个桌面，如果可以的话，麻烦大家告知一下谢谢。 所以解决的痛点在于：我要把一些操作尽量从 Windows 里面分离出来，例如终端软件，我能否在远程桌面外面操作，能否使用 SSH 来控制我的 Windows 机器。 好，有需求才有动力，说干就干。

配置

查了一下，Windows 上其实也是有 SSH 服务器的，只不过默认是没有装的，这里只需要安装一个 OpenSSH 服务器就好了。 Win10 的话，就在设置里面可以安装，从开始菜单打开“设置”，然后选择应用和功能，这里就有一个“管理可选功能”的选项。 点击之后便可以看到一个可选功能，选择 OpenSSH 服务器即可，一般情况下是没有安装的。如果没有安装的话它会提示一个安装按钮，这里我已经安装好了，就提示了一个卸载按钮。 OK，有了它，直接点击安装即可完成 OpenSSH 服务器的安装。 当然如果你是想批量部署 Windows 服务器的话，当然是推荐使用 PowerShell 来自动化部署了。 首先需要用管理员身份启动 PowerShell，使用如下命令看一下，要确保 OpenSSH 可用于安装：

1

Get-WindowsCapability -Online | ? Name -like 'OpenSSH*'

输出应该是类似的结果：

1
2
3
4

Name  : OpenSSH.Client~~~~0.0.1.0
State : NotPresent
Name  : OpenSSH.Server~~~~0.0.1.0
State : NotPresent

然后使用 PowerShell 安装服务器即可：

1

Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0

输出结果类似：

1
2
3

Path          :
Online        : True
RestartNeeded : False

这样也可以完成 OpenSSH 的安装。 安装完成之后，就需要进行一些初始化配置了，还是以管理员身份，使用 PowerShell 执行即可。 首先需要开启 SSHD 服务：

1

Start-Service sshd

然后设置服务的自动启动：

1

Set-Service -Name sshd -StartupType 'Automatic'

最后确认一下防火墙是否是放开的：

1

Get-NetFirewallRule -Name *ssh*

如果是放开的，那么结果会提示 OpenSSH-Server-In-TCP这个状态是 enabled。 好了，完成如上操作之后我们就可以使用 SSH 来连接我们的 Windows 服务器了。

连接

连接非常简单了，用户名密码就是 Windows 的用户名和密码，使用 IP 地址链接即可。 比如我的 Windows 开发机的局域网 IP 为：10.172.134.88，那么就可以使用如下命令完成链接：

1

ssh user@10.172.134.88

然后输入密码，就连接成功了，和 Linux 的是一样的。 另外我自己现在 Mac 常用的 SSH 客户端工具有 Termius，可以多终端同步使用，非常方便，这里我只需要添加我的 Windows 机器就好了，如图所示： OK，以后就可以非常轻松地用 SSH 连接我的 Windows 服务器了，爽歪歪，上面的需求也成功解决。 以上便是使用 SSH 来连接 Windows 服务器的方法，如果大家有需求可以试试。

都说程序猿是一类不解风情的生物，“赚的多，花的少，死的早”已经成为了程序猿的标志，“眼镜、格子衫、垢面蓬头、拖鞋裤衩”已然也成了程序猿的代表形象，“代码、游戏、老湿”也已经快要成了程序猿的生命。 但！有的时候，比如情人节，我们就可以发挥我们的特长了，我们程序猿也可以有自己的浪漫！ 不过这个第一步是，你得有一个女朋友（哦哦，是不是可以不用往下看了？ 那么有了第一步之后，下面我们应该怎么办呢？ 下面介绍一个比较实用的可以送给女朋友的礼物（这其实也是我今天送给女朋友的礼物嘿嘿。 首先想想，作为程序猿，我们的专长是什么？废话，当然是代码。 有了代码，还需要送口红吗？还需要送包包吗？还需要送鲜花吗？废话，都有了代码了，这些当然就….还是要送的。万一写的代码你女朋友看不懂那岂不是死翘翘了。 好那送完了口红或包包或鲜花之后，确保已经平安无事了，我们就可以再发挥我们的光和热了（听起来咋这么奇怪呢？ 进入正题，那我们可以利用代码做点什么呢？想想可以做文章的地方有什么，你们的纪念日，你们曾经做过的事情，你们在一起的时间，这些都是属于你们的独一无二的，我们可以想方设法把它们和代码联系起来。 那怎么发给女朋友看呢？做个 App、小程序、网页什么的都是可以的吧，其中网页可能是做起来最快最方便的了，然后配上一个专属域名，简直美滋滋。 好，那一想，基本方向就确定了，直接开干，接下来就描述一下我准备这个礼物的历程吧。 对于我来说，我就计划做一个网页，同时用代码的形式把和女朋友在一起的时间呈现出来，通过网页的动效来呈现我们在一起的时间，另外还计划把我们之间的故事用代码关联表示出来。 本来我打算是从零开始手撸一个的，但是一些组件比如动画特效，还有一些倒计时的组件是相对比较难做的，于是我就在 GitHub 上逛了一下，看了几个示例，找到了一个和我理想作品差不多的项目，然后在它的基础上做了一些改动，就成了最终的效果。 主要功能如下：

• 第一是通过代码来表述出来和女朋友之间的故事。由于我和女朋友是因为 Python 认识的，而且我们两个平时都会写一些 Python，所以我决定用 Python 来写出我们之间的故事，加上 Python 的注释来辅助描述每一行代码的意义。
• 第二是通过代码来呈现我和女朋友在一起的时间。这里就用上了一些动画特效和秒数计时方案，实时地呈现出来我和女朋友在一起已经有多久了。

最终完成之后的效果是这样子的： 然后由于我自己有一个域名，叫做 cuiqingcai.com，然后我就把它设置了二级域名解析，二级域名名称就叫做 love，域名最终就是 love.cuiqingcai.com。 最终的效果大家可以扫码或者复制链接查看一下最终的效果：http://love.cuiqingcai.com/，二维码如下： 感觉还可以吧？如果你也想送这样的礼物的话，可以根据我现有的代码来进行修改，我已经将源码放到 GitHub 了，地址为：https://github.com/Germey/ValentinesDay，大家可以修改源码，把它变成属于你和你女朋友的专属页面，然后送给女朋友。 下面说一些关键的技术和需要修改的点。

代码动画

打开页面之后，我们可以看到页面的代码是一个字一个字敲出来的，这实际上是利用了一个定时器来实现的。 首先我们可以预定义好所有的文本，然后动画播放的时候，首先把所有的文本隐藏，然后每隔几十毫秒读取一个字符，然后将其呈现出来。由于文本本身就是换行的，所以在呈现的时候就会一行一行地像打字机一样呈现出来。 另外为了模拟打字的效果，在呈现的时候可以在最后的字符后面添加一个下划线符号，模拟打字的效果。 其关键的实现代码如下：

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

(function (a) {
    a.fn.typewriter = function () {
        this.each(function () {
            var d = a(this), c = d.html(), b = 0;
            d.html("");
            var e = setInterval(function () {
                var f = c.substr(b, 1);
                if (f == "<") {
                    b = c.indexOf(">", b) + 1
                } else {
                    b++
                }
                d.html(c.substring(0, b) + (b & 1 ? "_" : ""));
                if (b >= c.length) {
                    clearInterval(e)
                }
            }, 75)
        });
        return this
    }
})(jQuery);

这里可以看到，首先获取了页面代码区域的内容，然后通过 DOM 操作将代码先清空，然后利用 setInterval 方法设置一个定时器，定时间隔 75 毫秒，也就是说 75 毫秒循环调用一次。每调用一次，就会从原来的字符上多取一个字符，然后尾部拼接一个下划线就好了。

代码内容

接下来就是代码内容了，这里面要想好怎样把一些关键时间来表示出来。比如和女朋友怎样认识的，后来什么时间在一起的，一起做过什么事情，将来有什么计划和打算，都可以来描述出来，另外编程语言可以选择你喜欢的语言，然后配以一定的注释来描述代码所代表的含义。 我和女朋友是在 PyCon 认识的，也算是因为 Python 结缘，然后平时我们都会写一些 Python，所以我就选用 Python 作为编程语言了。 然后我又加上了我们认识的时间、在一起的时间、一起做过的事情，然后再配以一段代码来表达自己的想法，其中的一些灵感也是我看了一些案例想出来的，在表述过程中我使用了面向对象的思维声明了两个对象，一个代表我，一个代表我女朋友，然后一起做过的事情就可以通过对象调用方法的形式来表述出来了，另外一些动作和标志可以通过自定义方法或者代码的参数来表示出来，其中每一行代码的动作我都配以一条 Python 的注释来完成，注释当然是用英文，一些话我还用了翻译软件一句句查的。 然后最后我用了一段 Python 代码来表达了自己的感情，内容如下：

1
2
3
4
5
6

# You are the greatest love of my life.
while True:
    if u.with(i):
        you = everything
    else:
        everything = u

这个代码的含义叫做“无论天涯海角，你都是我的一切。“，一个 while True 循环代表了永久。 这些代码其实都是在 HTML 代码中预定义好的，其中注释需要用 span 标签配以 comments 的 class 来修饰，缩进需要用 span 标签配以 placeholder 的 class 来修饰，例如：

1
2
3
4
5
6

<span class="comments"># You are the greatest love of my life.</span><br/>
while <span class="keyword">True</span>:<br/>
<span class="placeholder"></span><span class="keyword">if</span> u.with(i):<br/>
<span class="placeholder"></span><span class="placeholder"></span>you = everything<br/>
<span class="placeholder"></span><span class="keyword">else</span>:<br/>
<span class="placeholder"></span><span class="placeholder"></span>everything = u<br/>

这里不同的格式用 span 的不同 class 来标识，空格缩进一个 placeholder 是两个空格，comments 代表注释格式，关键词使用 keyword 来标识。如果你需要自定义自己的内容，通过控制这些内容穿插写入就好了。

纪念日计时

关于纪念日，这个实现起来其实挺简单的，就是首先定义好你们的纪念日，然后获取当前系统时间，然后计算秒数差值，然后将其转化为天数、小时数即可，关键核心代码实现如下：

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

function timeElapse(c) {
    var e = Date();
    var f = (Date.parse(e) - Date.parse(c)) / 1000;
    var g = Math.floor(f / (3600 * 24));
    f = f % (3600 * 24);
    var b = Math.floor(f / 3600);
    if (b < 10) {
        b = "0" + b
    }
    f = f % 3600;
    var d = Math.floor(f / 60);
    if (d < 10) {
        d = "0" + d
    }
    f = f % 60;
    if (f < 10) {
        f = "0" + f
    }
}

另外它也是通过一个定时器来实现的时间刷新，每隔 500 毫秒调用一次：

1
2
3

setInterval(function () {
    timeElapse(together);
}, 500);

动画心形

动画心形，其实这个实现起来是很巧妙的。这里在画的时候实际上是利用了贝塞尔曲线来绘制一个心形，同时在在画的过程中还加了花开的效果，花开的效果使用了随机数和随机颜色生成。 其中动画画心形的核心代码如下：

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

Petal.prototype = {
    draw: function () {
        var a = this.bloom.garden.ctx;
        var e, d, c, b;
        e = new Vector(0, this.r).rotate(Garden.degrad(this.startAngle));
        d = e.clone().rotate(Garden.degrad(this.angle));
        c = e.clone().mult(this.stretchA);
        b = d.clone().mult(this.stretchB);
        a.strokeStyle = this.bloom.c;
        a.beginPath();
        a.moveTo(e.x, e.y);
        a.bezierCurveTo(c.x, c.y, b.x, b.y, d.x, d.y);
        a.stroke()
    }, render: function () {
        if (this.r <= this.bloom.r) {
            this.r += this.growFactor;
            this.draw()
        } else {
            this.isfinished = true
        }
    }
};

这里最关键的一个部分就是 bezierCurveTo，这里传入的是绘制贝塞尔曲线的参数坐标，那这些坐标怎么生成的呢，这里是利用了数学上的一个桃心线方程，如图所示： 其中心形线的解析方程为： $x = 16(sint)^3 \\ y = 13cost-5cos2t-2cos3t-cos4t$ 这个公式代表了绘制坐标点的 x、y 的解析方程，用代码表示出来就是：

1
2
3
4
5
6

function getHeartPoint(c) {
    var b = c / Math.PI;
    var a = 19.5 * (16 * Math.pow(Math.sin(b), 3));
    var d = -20 * (13 * Math.cos(b) - 5 * Math.cos(2 * b) - 2 * Math.cos(3 * b) - Math.cos(4 * b));
    return new Array(offsetX + a, offsetY + d)
}

这里是生产了心形线方程的 x、y 坐标，然后再以此绘制出带有动画效果的心形。 最终呈现的效果就是现在你看到的样子。 不过这些在改代码的时候实际上不用关心，只需要修改你们在一起的时间就好了，就是代码中的这一行：

1
2

together.setFullYear(2018, 10, 5);
together.setHours(15);

这里修改你们在一起的时间和小时就可以了，然后页面就会自动更新你们在一起多久了，并动态呈现出来了。

域名解析

对于域名解析，这个建议大家可以申请一个域名，比如我的域名就是 cuiqingcai.com，我可以设置一个二级域名解析，叫做 love.cuiqingcai.com。 如果没有域名的话可以现买一个，比如阿里云、腾讯云购买，然后设置解析即可。 如果没有域名，也可以使用一些虚拟云服务器，他们会帮你设置二级域名，当然也可以使用 GitHub Pages，甚至你使用 IP 地址来访问也是没问题的。

项目代码

项目的代码我都放在了：https://github.com/Germey/ValentinesDay，大家可以自行修改成想要的样子送给女朋友，只能帮你到这里啦。 嘿嘿，这就是我今天送给女朋友的礼物，女朋友收到了开心得不得了，开心。

我的礼物

其实我今天也收到了女朋友送的特殊的礼物，可以说她确实花了不少心思啊，她送了我什么呢？令我没想到的是，她居然刚申请了一个微店，然后她微店上架了好多商品，我看到时候惊呆了，店铺如图所示： 里面上架了什么商品？洗水果服务？做饭刷碗服务？捏肩膀服务？还有自动哄老婆机？我惊了。 她把商品发给我，我好奇问她这是干嘛的。 她说：要获得我的洗水果服务，捏肩膀服务，只需要在我的小店里购买使用就好了（作掐腰状）！还有自动哄老婆机，你要惹我生气了，只需要购买一个自动哄老婆机，我就会不生气了！嘿嘿合不合算？ 我说：多少钱？999！这么贵的吗！ 她说：当然不是啦，亲亲我们店里有活动的，使用优惠券满 999 减 998 呢，您是我的 VIP 唯一专属客户，我会给您发优惠券的呀，使用优惠券只需要一块钱就可以购买了。购买之后，您每次使用一张，我就可以给您洗水果、捏肩膀了！这个情人节的话呢，我要送亲亲 10 张！可省着点话，不能累到店长我啊！ 哦哦，卧槽真牛逼啊！于是乎我就快快乐乐领取到了十张优惠券购买了女朋友的这些服务，等着时不时用一张，享受一下帝王级的待遇，美滋滋！哈哈~ 最后，祝大家情人节快乐！幸福！

作为一名程序员，能够利用好工具提高开发和工作效率是非常重要的。我个人使用的都是苹果系列产品，电脑为 MacBook Pro 15 寸，手机 iPhone 7P，另外还有一个 iPad Pro 和一副 Apple Watch。我一直觉得 Mac 是非常适合做程序开发的，它既有比较不错的页面，也有类 Unix 的操作系统，使得日常使用和程序开发都极其便利，另外由于苹果本身自有的 iCloud 机制，使用 Mac、iPhone、iPad 跨平台开发和工作也变得十分便利。

近期我又对自己的一些工具进行了整理，弃用了一些工具，新启用了一些工具。目的也只有一个，就是提高自己的工作和开发效率，让生活变得更美好。如果你也在用 Mac 开发，或者你也有使用 iPad、iPhone，下面我所总结的个人的一些工具或许能给你带来帮助。

快速导航

这是 Mac 上的一个工具，要说到提高效率，首推 Alfred，可以说是 Mac 必备软件，利用它我们可以快速地进行各种操作，大幅提高工作效率，如快速打开某个软件、快速打开某个链接、快速搜索某个文档，快速定位某个文件，快速查看本机 IP，快速定义某个色值，几乎我们能想到的都能对接实现。

其实 Mac 本身已经自带了软件搜索还有 Spotlight，但是其功能还是远远比不上 Alfred，有了它，所有的快捷操作几乎都能实现。

这些快速功能是怎么实现的呢？实际上是 Alfred 对接了很多 Workflow，我们可以使用 Workflow 方便地进行功能扩展，一些比较优秀的 Workflow 已经有人专门做过整理了，可以参见：https://github.com/zenorocha/alfred-workflows，大家可以安装自己所需要的 Workflow，大大提高效率。

复制粘贴

Mac 上默认只有一个粘贴板，当我们新复制了一段文字之后，如果我们想再找寻之前复制的历史记录就找不到了，这其实是很反人类的。

好在 Paste 这款软件帮我们解决了这个问题，它可以保存我们粘贴板的历史记录，等需要粘贴某个内容的时候只需要呼出 Paste 历史粘贴板，然后选择某个特定的内容粘贴就好了，另外它还支持文本格式调整粘贴板分类和搜索，还可以支持快速便捷粘贴。有了它，再也不用担心粘贴板丢失了！

另外使用 Mac 和 iPhone、iPad 之间也可以相互之间复制粘贴，可以在一台 Apple 设备上拷贝文本、图像、照片和视频，然后在另一台 Apple 设备上粘贴该内容。例如，可以拷贝在 Mac 上浏览网页时发现的食谱，然后将其粘贴到附近 iPhone 上“备忘录”中的购物清单。这是在 macOS Sierra 版本之后出来的功能，若要使用需要确保 Mac 的版本是 Sierra 及以后。若要使用，几个设备必须满足“连续互通”系统要求。它们还必须在“系统偏好设置”（在 Mac 上）和“设置”（在 iOS 设备上）中打开 Wi-Fi、蓝牙和 Handoff，另外必须在所有设备上使用同一 Apple ID登录 iCloud。

具体的操作流程可以参见苹果的官网说明：https://support.apple.com/kb/PH25168，有了这个功能，日常的一些操作便可以直接同步了，甚至不再需要 AirDrop，更不需要微信和邮件。

时间管理

现在这个时候，时间比什么都重要，每个人的时间都是公平的，如果我们能够合理规划好自己的时间和工作，这就跨出了成功的一步。

我曾经尝试用手写的方式来记录自己的一些任务，但总感觉它有一些并不方便的地方。比如某时某刻突然想起来，想要添加一件事情或者完成了一件事情，或者想要修改截止时间，或者想要划分优先级，其实都不怎么方便。最好的方式还是通过一些专用的时间管理软件来分配分配和管理自己的时间。

我曾经使用过非常多款时间管理工具，最终我选择的是 Todoist，这个是我感觉体验非常不错的一款。这个软件里面基本的任务添加与勾划功能当然必不可少，它也支持优先级管理，分类管理，时间设置，另外还有几个我觉得非常加分的几个点，比如：

• 添加时间时可以直接通过一句话来添加，比如”每隔两天晚上九点运动”，它会自动识别并设置为循环任务，并能在相应的时刻提醒你。

• 支持全部平台，不论是网页还是 Windows、Mac、Android、iPhone、iPad、Apple Watch、Chrome、Firefox，你能想到的平台，应有尽有。

• 它还支持事件同步，可以在 Mac 或者 iPhone 的日历中添加 Todoist 的同步，这样你所有的事情都会被定时同步到日历软件中，这样日历中就既包含了节日、生日等信息，又可以把每天我们需要做的事同步进来，日程信息一目了然。这样你就可以把日历变成一个提醒器，设置什么时候提醒就好了，现在我就在用 Mac 或者 iPhone 上的日历来提醒我什么时间该做什么事情了。

• 它还支持多人写作，就类似于 Worktile、Teambition、Trello，我曾经使用这款软件完成了多个项目的任务分配和多人协作开发，还是非常方便的。

• 另外它还支持过期智能重新安排任务，比如有一些任务没有完成，它还可以根据优先级来重新进行时间规划和安排，同时也有任务评分和目标评价机制，来反映我们任务完成情况。

另外关于时间管理还有一个非常重要的四象限法则，大家也可以了解一下。有了这个法则，大家可以合理安排优先级，合理分配每个任务的时间。有关于我的时间管理经验我后面还会详细写一篇相关的文章，介绍一下我平时会怎样进行时间规划和学习的。

另外我还尝试过番茄土豆这个软件，这个软件的缺点在于整体的功能还比较简陋，而且不能和我已有的 Todo List 进行同步。好处就是可以自己设置番茄，保持专注工作。但目前我尚未发现满意的产品，如有还希望大家可以留言推荐一下，谢谢。

笔记记录

在学习的时候来进行记录是非常非常重要的，强烈建议一边学习一边把所做所想记录下来，最后做一下整理成文。一方面方便查阅，另一方面加深印象和理解。

Markdown 想必大家都已经很耳熟了，现在我写文章或者笔记几乎全都用 Markdown 来写，现在很多云笔记也慢慢逐步支持 Markdown 的语法了，我的博客后台也自己配置了 Markdown 的支持。不过也有某些平台尚未支持 Markdown，比如知乎，忍不住吐槽一句，知乎的编辑器实在用得是心累，当然可以使用插件来解决，也当然也有所好，我就不再说什么了。不过我还是强烈推荐 Markdown 来进行写作和记录的，用过之后你可能就不再想用 Word 了。

言归正传，既然谈到笔记和写作。我的笔记本是 Mac，之前几乎所有的笔记，包括写书，都几乎是在 Mac 上完成的，但是确实有的时候是不方便的。比如 Mac 不在身边或者想用 iPhone 或者 iPad 来写点东西的时候，一个需要解决的问题就是云同步问题。有了云同步，我们如果在电脑上写了一部分内容，接着切换了另一台台式机，或者切换了手机的时候，照样能够接着在原来的基础上写，非常方便。

这时候可能就有小伙伴推荐有道云笔记、印象笔记等软件，它们支持 Markdown，但这并不是它们的主打支持方向，对 Makrdown 的支持当然没有一些专业的 Makrdown 编辑工具专业。对我个人而言，我不想因为它们自带了云同步而抛弃了纯粹的 Makrdown 写作环境，我只想要一个纯粹的 Makrdown 写作环境，而不想引入比如有道云里面的普通笔记、签到等冗余的功能，也不想看到里面的广告推荐等内容。所以对于云同步，我使用了另外的解决方案。对于写作软件，我也摸索出了自己的一套方案。

对于电脑端的 Markdown 写作软件，推荐两款，一款是 Typora，另一款是 MarkEditor。

对于 Makrdown 编辑器来说，我觉得有几个比较重要的点：

• 不能纯写 Makrdown，要实时地能够看到自己写完 Makrdown 之后最终呈现的效果是怎样的。

• 插入图片要方便，很多编辑器需要先将图片挪到某个文件夹下或者上传图片才可以插入图片，这是很不友好的，如果能够直接通过复制粘贴的形式插入图片，甚至能够自动将图片上传到云端，那就再好不过了。

• 能够打开一整个 Makrdown 文件夹，左侧显示文件列表，右侧进行写作编辑，不能仅仅支持一个 Markdown 文件的编辑。

• 如果需要用到公司，那么编辑器需要对 Markdown 公式支持比较好。

以上介绍的这两款软件都可以做到。

• Typora 是免费的，更加轻量级，而且支持即写即得，界面支持和公式支持都比较好，图片的话可以结合 iPic 软件直接上传到图床，同时也可以直接将复制的图片直接粘贴到编辑器中，非常友好，目前我正在使用。

• MarkEditor 是收费的，功能更为丰富，支持左右分栏模式、阅读模式等，它也支持直接复制和粘贴图片，另外还有强大的导出功能，还可以直接将文件发布为一个网站等等，也十分推荐。

不过目前由于 Typora 更轻量级，并且能和 iPic 而且功能配合使用，粘贴后的图片可以点击直接上传到云端，非常方便，我目前已经由 MarkEditor 切换到 Typora 了。

写作界面如下：

如图这是打开了一个文件夹，这个文件夹里面有好多 Makrdown 文件，都是我在研究和学习过程中所写的笔记。

然后需要解决的就是云同步问题，云同步其实使用网盘就足够了。由于我使用 Mac，所以我选用了 iCloud，开了 200G 的空间，足够了。这样我所记录的内容能够秒级同步到 iCloud Drive 中，这样我再使用 iPhone、iPad 就可以直接看到最新的内容了。当然还有一些推荐的，比如 OneDrive、谷歌云等多种云盘同步工具，哪个方便用哪个。Mac 和 iPhone 的好处就是已经内置了 iCloud Drive，所以不用再去在各个终端上配置了。

接下来就是在其他的电脑以及 iPhone、iPad 上进行写作的解决方案了。由于我的文件都已经存放在了 iCloud Drive，所以就需要一款 Makrdown 编辑软件可以直接读写 iCloud Drive 里面的内容，同时界面还要友好，功能完善一点。在这里我最终选择了 Markdown Pro，它的功能简洁但是又比较完善，打开之后直接选取 iCloud Drive 里面的 Makrdown 文件即可开始编辑，并且它是左右分栏的，即左侧编辑，右侧预览，非常方便简洁，另外它对公式的支持也很好，下图是我在 iPad 上对本文进行编辑的效果预览图。

对于图片的插入，在 iPhone 和 iPad 上我借助了另外一个工具，叫做 SM.MS，这个软件可以直接选取图片，然后上传到云端，点击复制即可得到链接和 Makrdown 图片链接，所以插图也不是什么问题了。

如图所示，上传照片之后，便会出现各种各样的图片链接形式，有纯链接、HTML、Markdown 等等，直接点击复制按钮即可复制，然后粘贴到文档中。

另外如果你用了 Windows 的话，只要下载一个 iCloud 云盘软件即可同步。如果使用的是其他的云盘软件，也只需要配置一下就好了。

有了这套，我们就可以实现随时随地写笔记，Mac、iPhone、iPad 无缝切换。

思维导图

很多时候我们在构思方案或者流程的时候需要对思维做梳理，或者在列方案呈现的时候也需要分门别类地进行呈现。这时候大多数情况下就需要用到一个工具，思维导图。

思维导图工具我个人使用的是 MindNode，在 Mac 上用它可以通过各种快捷键快速的增删思维导图节点，另外界面也非常绚丽多彩。

对于思维导图软件来说，我也希望能全平台同步，其实 MindNode 也有对应的移动端软件，同样是 MindNode，二者可以通过 iCloud Drive 进行同步，同样可以做到无缝衔接。

另外还有很多朋友也在用 XMind，功能同样很强大，大家也可以试试。

远程控制

我们经常会和各种服务器打交道，例如我们经常使用 SSH 来远程连接某台 Linux 服务器，原生 Terminal 是支持 SSH 的，但你会发现原生带的这个太难用了。可能很多小伙伴使用 iTerm，不得不说这确实是个神器，大大方便了远程管理流程。但我在这里还要推荐一个我经常使用的 SSH Shell，没错，它的名字就是 SSH Shell，它的页面操作简洁，同时管理和记录远程主机十分方便，另外还支持秘钥管理、自动重连、自定义主题等等功能，个人用起来十分顺手，强烈推荐！

当然除了电脑，当我们出去在外的时候，紧急情况也可能需要使用 SSH 来连接和管理我们的服务器，所以我也在 iPhone 和 iPad 上装了远程管理软件，叫做 Termius，同样功能十分强大，快捷操作十分便捷，有免费的试用期限，我觉得非常好用就订购了，推荐给大家。

代码记录

作为一名程序员，我们会经常写或者使用一些关键代码。

比如有一天我写了一些方法，这些方法可以完成非常重要的功能，后面的项目也会经常遇到，那么怎么办呢？很多情况下我们想把它保存起来，放到某个收藏夹里面备用，等到用的时候重新把它复制出来。或者有一些繁琐的命令，我实在是记不住，或许我们也想把它记录下来。

很多情况下，我们可能简单地使用文本文件，但并不方便同步和查找。或者云笔记保存下来，但这些并不是专门用来保存代码的。更高级一点，我们会联想到使用 GitHub Gists，但每次记录的这个流程也比较麻烦。

这里推荐一个专门用来记录代码片段的软件，叫做 SnippetsLab，适用于 Mac 系统，可以专门用来管理代码片段，还支持多种代码格式。比如我就将代码按照编程语言划分，划分为 Python、JavaScript 等等，分文件夹存储，有不错的代码就随手贴过来，另外它也支持搜索，管理代码非常方便。如果某一天想查某个代码了，直接打开它一搜就有了，可以大大提高开发效率。

以上就暂且总结这么多，其实还有不少好用的用具，后面再一一为大家总结分享。

另外再问下大家，你们买 iPad 了吗？是不是觉得比较鸡肋，或者平时都用不上，那这样就没有发挥 iPad 的最大效用，如果利用好了，它可以进一步方便我们的生活，后面我也会专门写一下 iPad 方面的一些用途。

由于水平和见识有限，如果大家有更好的软件或者方案推荐，欢迎大家留言！也希望我的一些方案对大家有所帮助，谢谢！

爬虫是做什么的？是帮助我们来快速获取有效信息的。然而做过爬虫的人都知道，解析是个麻烦事。 比如一篇新闻吧，链接是这个：https://news.ifeng.com/c/7kQcQG2peWU，页面预览图如下： 我们需要从页面中提取出标题、发布人、发布时间、发布内容、图片等内容。一般情况下我们需要怎么办？写规则。 那么规则都有什么呢？怼正则，怼 CSS 选择器，怼 XPath。我们需要对标题、发布时间、来源等内容做规则匹配，更有甚者再需要正则表达式来辅助一下。我们可能就需要用 re、BeautifulSoup、pyquery 等库来实现内容的提取和解析。 但如果我们有成千上万个不同样式的页面怎么办呢？它们来自成千上万个站点，难道我们还需要对他们一一写规则来匹配吗？这得要多大的工作量啊。另外这些万一弄不好还会解析有问题。比如正则表达式在某些情况下匹配不了了，CSS、XPath 选择器选错位了也会出现问题。 想必大家可能见过现在的浏览器有阅读模式，比如我们把这个页面用 Safari 浏览器打开，然后开启阅读模式，看看什么效果： 页面一下子变得非常清爽，只保留了标题和需要读的内容。原先页面多余的导航栏、侧栏、评论等等的统统都被去除了。它怎么做到的？难道是有人在里面写好规则了？那当然不可能的事。其实，这里面就用到了智能化解析了。 那么本篇文章，我们就来了解一下页面的智能化解析的相关知识。

智能化解析

所谓爬虫的智能化解析，顾名思义就是不再需要我们针对某一些页面来专门写提取规则了，我们可以利用一些算法来计算出来页面特定元素的位置和提取路径。比如一个页面中的一篇文章，我们可以通过算法计算出来，它的标题应该是什么，正文应该是哪部分区域，发布时间是什么等等。 其实智能化解析是非常难的一项任务，比如说你给人看一个网页的一篇文章，人可以迅速找到这篇文章的标题是什么，发布时间是什么，正文是哪一块，或者哪一块是广告位，哪一块是导航栏。但给机器来识别的话，它面临的是什么？仅仅是一系列的 HTML 代码而已。那究竟机器是怎么做到智能化提取的呢？其实这里面融合了多方面的信息。

• 比如标题。一般它的字号是比较大的，而且长度不长，位置一般都在页面上方，而且大部分情况下它应该和 title 标签里的内容是一致的。
• 比如正文。它的内容一般是最多的，而且会包含多个段落 p 或者图片 img 标签，另外它的宽度一般可能会占用到页面的三分之二区域，并且密度（字数除以标签数量）会比较大。
• 比如时间。不同语言的页面可能不同，但时间的格式是有限的，如 2019-02-20 或者 2019/02/20 等等，也有的可能是美式的记法，顺序不同，这些也有特定的模式可以识别。
• 比如广告。它的标签一般可能会带有 ads 这样的字样，另外大多数可能会处于文章底部、页面侧栏，并可能包含一些特定的外链内容。

另外还有一些特点就不再一一赘述了，这其中包含了区块位置、区块大小、区块标签、区块内容、区块疏密度等等多种特征，另外很多情况下还需要借助于视觉的特征，所以说这里面其实结合了算法计算、视觉处理、自然语言处理等各个方面的内容。如果能把这些特征综合运用起来，再经过大量的数据训练，是可以得到一个非常不错的效果的。

业界进展

未来的话，页面也会越来越多，页面的渲染方式也会发生很大的变化，爬虫也会越来越难做，智能化爬虫也将会变得越来越重要。 目前工业界，其实已经有落地的算法应用了。经过我的一番调研，目前发现有这么几种算法或者服务对页面的智能化解析做的比较好：

• Diffbot，国外的一家专门来做智能化解析服务的公司，https://www.diffbot.com
• Boilerpipe，Java 语言编写的一个页面解析算法，https://github.com/kohlschutter/boilerpipe
• Embedly，提供页面解析服务的公司，https://embed.ly/extract
• Readability，是一个页面解析算法，但现在官方的服务已经关闭了，https://www.readability.com/
• Mercury，Readability 的替代品，https://mercury.postlight.com/
• Goose，Java 语音编写的页面解析算法，https://github.com/GravityLabs/goose

那么这几种算法或者服务到底哪些好呢，Driffbot 官方曾做过一个对比评测，使用 Google 新闻的一些文章，使用不同的算法依次摘出其中的标题和文本，然后与真实标注的内容进行比较，比较的指标就是文字的准确率和召回率，以及根据二者计算出的 F1 分数。 其结果对比如下：

Service/Software

Precision

Recall

F1-Score

Diffbot

0.968

0.978

0.971

Boilerpipe

0.893

0.924

0.893

Readability

0.819

0.911

0.854

AlchemyAPI

0.876

0.892

0.850

Embedly

0.786

0.880

0.822

Goose

0.498

0.815

0.608

经过对比我们可以发现，Diffbot 的准确率和召回率都独占鳌头，其中的 F1 值达到了 0.97，可以说准确率非常高了。另外接下来比较厉害的就是 Boilerpipe 和 Readability，Goose 的表现则非常差，F1 跟其他的算法差了一大截。下面是几个算法的 F1 分数对比情况： 有人可能好奇为什么 Diffbot 这么厉害？我也查询了一番。Diffbot 自 2010 年以来就致力于提取 Web 页面数据，并提供许多 API 来自动解析各种页面。其中他们的算法依赖于自然语言技术、机器学习、计算机视觉、标记检查等多种算法，并且所有的页面都会考虑到当前页面的样式以及可视化布局，另外还会分析其中包含的图像内容、CSS 甚至 Ajax 请求。另外在计算一个区块的置信度时还考虑到了和其他区块的关联关系，基于周围的标记来计算每个区块的置信度。 总之，Diffbot 也是一直致力于这一方面的服务，整个 Diffbot 就是页面解析起家的，现在也一直专注于页面解析服务，准确率高也就不足为怪了。 但它们的算法开源了吗？很遗憾，并没有，而且我也没有找到相关的论文介绍它们自己的具体算法。 所以，如果想实现这么好的效果，那就使用它们家的服务就好了。 接下来的内容，我们就来说说如何使用 Diffbot 来进行页面的智能解析。另外还有 Readability 算法也非常值得研究，我会写专门的文章来介绍 Readability 及其与 Python 的对接使用。

Diffbot 页面解析

首先我们需要注册一个账号，它有 15 天的免费试用，注册之后会获得一个 Developer Token，这就是使用 Diffbot 接口服务的凭证。 接下来切换到它的测试页面中，链接为：https://www.diffbot.com/dev/home/，我们来测试一下它的解析效果到底是怎样的。 这里我们选择的测试页面就是上文所述的页面，链接为：https://news.ifeng.com/c/7kQcQG2peWU，API 类型选择 Article API，然后点击 Test Drive 按钮，接下来它就会出现当前页面的解析结果： 这时候我们可以看到，它帮我们提取出来了标题、发布时间、发布机构、发布机构链接、正文内容等等各种结果。而且目前来看都十分正确，时间也自动识别之后做了转码，是一个标准的时间格式。 接下来我们继续下滑，查看还有什么其他的字段，这里我们还可以看到有 html 字段，它和 text 不同的是，它包含了文章内容的真实 HTML 代码，因此图片也会包含在里面，如图所示： 另外最后面还有 images 字段，他以列表形式返回了文章套图及每一张图的链接，另外还有文章的站点名称、页面所用语言等等结果，如图所示： 当然我们也可以选择 JSON 格式的返回结果，其内容会更加丰富，例如图片还返回了其宽度、高度、图片描述等等内容，另外还有各种其他的结果如面包屑导航等等结果，如图所示： 经过手工核对，发现其返回的结果都是完全正确的，准确率相当之高！ 所以说，如果你对准确率要求没有那么非常非常严苛的情况下，使用 Diffbot 的服务可以帮助我们快速地提取页面中所需的结果，省去了我们绝大多数的手工劳动，可以说是非常赞了。 但是，我们也不能总在网页上这么试吧。其实 Diffbot 也提供了官方的 API 文档，让我们来一探究竟。

Diffbot API

Driffbot 提供了多种 API，如 Analyze API、Article API、Disscussion API 等。 下面我们以 Article API 为例来说明一下它的用法，其官方文档地址为：https://www.diffbot.com/dev/docs/article/，API 调用地址为：

1

https://api.diffbot.com/v3/article

我们可以用 GET 方式来进行请求，其中的 Token 和 URL 都可以以参数形式传递给这个 API，其必备的参数有：

• token：即 Developer Token
• url：即要解析的 URL 链接

另外它还有几个可选参数：

• fields：用来指定返回哪些字段，默认已经有了一些固定字段，这个参数可以指定还可以额外返回哪些可选字段
• paging：如果是多页文章的话，如果将这个参数设置为 false 则可以禁止多页内容拼接
• maxTags：可以设置返回的 Tag 最大数量，默认是 10 个
• tagConfidence：设置置信度的阈值，超过这个值的 Tag 才会被返回，默认是 0.5
• discussion：如果将这个参数设置为 false，那么就不会解析评论内容
• timeout：在解析的时候等待的最长时间，默认是 30 秒
• callback：为 JSONP 类型的请求而设计的回调

这里大家可能关注的就是 fields 字段了，在这里我专门做了一下梳理，首先是一些固定字段：

• type：文本的类型，这里就是 article 了
• title：文章的标题
• text：文章的纯文本内容，如果是分段内容，那么其中会以换行符来分隔
• html：提取结果的 HTML 内容
• date：文章的发布时间，其格式为 RFC 1123
• estimatedDate：如果日期时间不太明确，会返回一个预估的时间，如果文章超过两天或者没有发布日期，那么这个字段就不会返回
• author：作者
• authorUrl：作者的链接
• discussion：评论内容，和 Disscussion API 返回结果一样
• humanLanguage：语言类型，如英文还是中文等
• numPages：如果文章是多页的，这个参数会控制最大的翻页拼接数目
• nextPages：如果文章是多页的，这个参数可以指定文章后续链接
• siteName：站点名称
• publisherRegion：文章发布地区
• publisherCountry：文章发布国家
• pageUrl：文章链接
• resolvedPageUrl：如果文章是从 pageUrl 重定向过来的，则返回此内容
• tags：文章的标签或者文章包含的实体，根据自然语言处理技术和 DBpedia 计算生成，是一个列表，里面又包含了子字段：
  • label：标签名
  • count：标签出现的次数
  • score：标签置信度
  • rdfTypes：如果实体可以由多个资源表示，那么则返回相关的 URL
  • type：类型
  • uri：Diffbot Knowledge Graph 中的实体链接
• images：文章中包含的图片
• videos：文章中包含的视频
• breadcrumb：面包屑导航信息
• diffbotUri：Diffbot 内部的 URL 链接

以上的预定字段就是如果可以返回那就会返回的字段，是不能定制化配置的，另外我们还可以通过 fields 参数来指定扩展如下可选字段：

• quotes：引用信息
• sentiment：文章的情感值，-1 到 1 之间
• links：所有超链接的顶级链接
• querystring：请求的参数列表

好，以上便是这个 API 的用法，大家可以申请之后使用这个 API 来做智能化解析了。 下面我们用一个实例来看一下这个 API 的用法，代码如下：

1
2
3
4
5
6
7
8
9
10

import requests, json

url = 'https://api.diffbot.com/v3/article'
params = {
    'token': '77b41f6fbb24496d5113d528306528fa',
    'url': 'https://news.ifeng.com/c/7kQcQG2peWU',
    'fields': 'meta' 
}
response = requests.get(url, params=params)
print(json.dumps(response.json(), indent=2, ensure_ascii=False))

这里首先定义了 API 的链接，然后指定了 params 参数，即 GET 请求参数。 参数中包含了必选的 token、url 字段，也设置了可选的 fields 字段，其中 fields 为可选的扩展字段 meta 标签。 我们来看下运行结果，结果如下：

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

{
  "request": {
    "pageUrl": "https://news.ifeng.com/c/7kQcQG2peWU",
    "api": "article",
    "fields": "sentiment, meta",
    "version": 3
  },
  "objects": [
    {
      "date": "Wed, 20 Feb 2019 02:26:00 GMT",
      "images": [
        {
          "naturalHeight": 460,
          "width": 640,
          "diffbotUri": "image|3|-1139316034",
          "url": "http://e0.ifengimg.com/02/2019/0219/1731DC8A29EB2219C7F2773CF9CF319B3503D0A1_size382_w690_h460.png",
          "naturalWidth": 690,
          "primary": true,
          "height": 426
        },
        // ...
      ],
      "author": "中国新闻网",
      "estimatedDate": "Wed, 20 Feb 2019 06:47:52 GMT",
      "diffbotUri": "article|3|1591137208",
      "siteName": "ifeng.com",
      "type": "article",
      "title": "故宫，你低调点！故宫：不，实力已不允许我继续低调",
      "breadcrumb": [
        {
          "link": "https://news.ifeng.com/",
          "name": "资讯"
        },
        {
          "link": "https://news.ifeng.com/shanklist/3-35197-/",
          "name": "大陆"
        }
      ],
      "humanLanguage": "zh",
      "meta": {
        "og": {
          "og:time ": "2019-02-20 02:26:00",
          "og:image": "https://e0.ifengimg.com/02/2019/0219/1731DC8A29EB2219C7F2773CF9CF319B3503D0A1_size382_w690_h460.png",
          "og:category ": "凤凰资讯",
          "og: webtype": "news",
          "og:title": "故宫，你低调点！故宫：不，实力已不允许我继续低调",
          "og:url": "https://news.ifeng.com/c/7kQcQG2peWU",
          "og:description": "　　“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。” 　　“重"
        },
        "referrer": "always",
        "description": "　　“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。” 　　“重",
        "keywords": "故宫 紫禁城 故宫博物院 灯光 元宵节 博物馆 一票难求 元之 中新社 午门 杜洋 藏品 文化 皇帝 清明上河图 元宵 千里江山图卷 中英北京条约 中法北京条约 天津条约",
        "title": "故宫，你低调点！故宫：不，实力已不允许我继续低调_凤凰资讯"
      },
      "authorUrl": "https://feng.ifeng.com/author/308904",
      "pageUrl": "https://news.ifeng.com/c/7kQcQG2peWU",
      "html": "<p>“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。...</blockquote> </blockquote>",
      "text": "“我的名字叫紫禁城，快要600岁了，这上元的夜啊，总是让我沉醉，这么久了却从未停止。”\\n“...",
      "authors": [
        {
          "name": "中国新闻网",
          "link": "https://feng.ifeng.com/author/308904"
        }
      ]
    }
  ]
}

可见其返回了如上的内容，是一个完整的 JSON 格式，其中包含了标题、正文、发布时间等等各种内容。 可见，不需要我们配置任何提取规则，我们就可以完成页面的分析和抓取，得来全不费功夫。

Diffbot SDK

另外 Diffbot 还提供了几乎所有语言的 SDK 支持，我们也可以使用 SDK 来实现如上功能，链接为：https://www.diffbot.com/dev/docs/libraries/，如果大家使用 Python 的话，可以直接使用 Python 的 SDK 即可，Python 的 SDK 链接为：https://github.com/diffbot/diffbot-python-client。 这个库并没有发布到 PyPi，需要自己下载并导入使用，另外这个库是使用 Python 2 写的，其实本质上就是调用了 requests 库，如果大家感兴趣的话可以看一下。 下面是一个调用示例：

1
2
3
4
5
6
7

from client import DiffbotClient,DiffbotCrawl

diffbot = DiffbotClient()
token = 'your_token'
url = 'http://shichuan.github.io/javascript-patterns/'
api = 'article'
response = diffbot.request(url, token, api)

通过这行代码我们就可以通过调用 Article API 来分析我们想要的 URL 链接了，返回结果是类似的。 具体的用法大家直接看下它的源码注释就一目了然了，还是很清楚的。 好，以上便是对智能化提取页面原理的基本介绍以及对 Diffbot 的用法的讲解，后面我会继续介绍其他的智能化解析方法以及一些相关实战，希望大家可以多多关注。

大家好，我是四毛，欢迎关注我的公众号。

有什么想要交流的可以在后台第一时间私我。

今天的文章内容主要是关于字体反爬。

目前已知的几个字体反爬的网站是猫眼，汽车之家，天眼查，起点中文网等等。 以前也看过这方面的文章，今天跟个老哥在交流的时候，终于实操了一把，弄懂了字体反爬是个啥玩意。下面听我慢慢道来。

本文用到的第三方库

fontTools

1、目标网站

url = “https://su.58.com/qztech/“

2、反爬虫机制

网页上看见的 后台源代码里面的 从上面可以看出，生这个字变成了乱码，请大家特别注意箭头所指的数字。

3、解决

1、确定反爬方法

在看了别人的解析文章之后，确定采取的是字体反爬机制，即网站定义了字体文件，然后进行相应的查找替换，在前端看起来，是没有任何差异的。其实从审查元素的也是可以看到的： 和大众点评的反爬差不多，都是通过 css 搞得。

2、寻找字体文件

以上面方框里的”customfont“为关键词搜了一下，发现就在源代码里面： 而且还有 base64，直接进行解密，但是解密出来的其实是乱码，这个时候其实要做的很简单，把解密后的内容保存为.ttf格式即可。

ttf 文件： *.ttf 是字体文件格式。TTF(TrueTypeFont)是 Apple 公司和 Microsoft 公司共同推出的字体文件格式,随着 windows 的流行,已经变成最常用的一种字体文件表示方式。 @font-face 是 CSS3 中的一个模块，主要是实现将自定义的 Web 字体嵌入到指定网页中去。

因为我们要对字体进行研究，所以必须将它打开，这里我是用的是FontCreator，打开以后是这个样子（其实很多字，在这里为了看的清楚，所以只截了下面的图）： 很明显，每个字可以看到字形和字形编码。 观察现在箭头指的地方和前面箭头指的地方的数字是不是一样啊，没错，就是通过这种方法进行映射的。 所以我们现在的思路似乎就是在源代码里找到箭头指的数字，然后再来字体里找到后替换就行了。 恭喜你，如果你也是这么想的，那你就掉坑里了。 因为每次访问，字体字形是不变的，但字符的编码确是变化的。因此，我们需要根据每次访问，动态解析字体文件。 字体 1： 字体 2： 所以想通过写死的方式也是行不通的。 这个时候我们就要对字体文件进行更深一步的研究了。 3、研究字体文件 刚刚的.ttf 文件我们是看不到内部的东西的，所以这个时候我们要对字体文件进行转换格式，将其转换为 xml 格式，然后来查看： 具体操作如下：

1
2
3

from fontTools.ttLib import TTFont
font_1 = TTFont('58_font_1.ttf')
font_base.saveXML('font_1.xml')

xml 的格式如下： 文件很长，我只截取了一部分。 仔细的观察一下，你会发现~这俩下面的 x,y,on 值都是一毛一样的。所以我们的思路就是以一个已知的字体文件为基本，然后将获取到的新的字体文件的每个文字对应的 x,y,on 值进行比较，如果相同，那么说明新的文字对就 可以在基础字体那里找到对应的文字，有点绕，下面举个小例子。 假设: “我” 在基本字体中的名为 uni1，对应的 x=1,y=1,n=1 新的字体文件中，一个名为 uni2 对应的 x，y, n 分别于上面的相等，那么这个时候就可以确定 uni2 对应的文字为”我”。 查资料的时候，发现在特殊情况下，有时候两个字体中的文字对应的 x,y 不相等，但是差距都是在某一个阈值之内，处理方法差不多，只不过上面是相等，这种情况下就是要比较一下。 其实，如果你用画图工具按照上面的 x 与 y 值把点给连起来，你会发现，就是汉字的字形~ 所以，到此总结一下：

一、将某次请求获取到的字体文件保存到本地[基本字体]； 二、用软件打开后，人工的找出每一个数字对应的编码[ 一定要保证顺序的正确，要不然会出事]； 三、我们以后访问网页时，需要保存新字体文件； 四、用 Fonttools 库对基本字体与新字体进行处理，找 到新的字体与基本字体之间的映射； 五、替换；

4、上代码

微信里上代码真的太丑了， 还是算了吧，微信后台关键词“字体加密” 即可获取 github 地址。 看一下成果

总结

其实这个流程最大的问题就是我们人工录入的基本字体的字典数据有可能是会发生变化的，这就导致我们后面还要手动去改。 现在，如果你已经看懂了本文，那么还不快去其他几个网站试试？ 如果有任何问题，欢迎交流。

大家好，我是四毛，欢迎大家关注我的公众号。

今天在工作中，碰到了第一次碰见的反爬虫机制，感觉很有意思，在这里记录一下，希望对大家有帮助。

今天用到的库：

requests [请求] lzstring [解压数据] pyexecjs [执行 JS]

简单粗暴，直接上网站部分源代码，因为这个网站应该不太希望别人来爬，所以就不上网站了。为什么这么说，因为刚开始请求的时候，老是给我返回 GO TO HELL ，哈哈。 这个网站点击鼠标右键审查元素，查看网页源代码是无法用的，但是这个好像只能防住小白啊，简单的按 F12 审查元素，CTRL+u 直接查看源代码（谷歌浏览器）。 这次的目的主要是为了获取下面的链接（重度打码）

xxxxxxxxxxx/xxxxx-003-a5f7xxxxxx?cid=xxxxx&xxx=siOE_q4XxBtwdoXqD0xxxx

其中，红色加粗的就是我们要找的变量了。

一、观察与抓包

首先，我观察到了网页源代码中的一部分 js 代码：

type=”text/javascript”>window“\x65\x76\x61\x6c”{e=function(c){return(c35?String.fromCharCode(c+29):c.toString(36))};if(!’’.replace(/^/,String)){while(c—)d[e(c)]=k[c]||e(c);k=[function(e){return d[e]}];e=function(){return’\\w+’};c=1;};while(c—)if(k[c])p=p.replace(new RegExp(‘\\b’+e(c)+’\\b’,’g’),k[c]);return p;}(‘29.2a({“2c”:1k,”26”:”21”,”22”:”1k.24”,”2o”:2n,”2s”:”2r”,”2l”:[“0-2f-2e.3.2”,”0-2j-2i.3.2”,”0-1r-1L.3.2”,”0-1r-1K.3.2”,”0-1e-1X.3.2”,”0-1e-1Q.3.2”,”0-1x-1W.3.2”,”0-1x-1M.3.2”,”0-1B-33.3.2”,”0-1B-36.3.2”,”0-1F-30.3.2”,”0-1F-2U.3.2”,”0-1g-2Y.3.2”,”0-1g-3e.3.2”,”0-1q-3i.3.2”,”0-1q-38.3.2”,”0-1o-37.3.2”,”0-1o-3a.3.2”,”0-1s-2B.3.2”,”0-1s-2E.3.2”,”0-1i-2v.3.2”,”0-1i-2y.3.2”,”0-1G-2P.3.2”,”0-1G-2S.3.2”,”0-1E-2R.3.2”,”0-1E-2H.3.2”,”0-1I-2L.3.2”,”0-1I-2J.3.2”,”0-t-2K.3.2”,”0-t-2G.3.2”,”0-p-2I.3.2”,”0-p-2M.3.2”,”0-o-2Q.3.2”,”0-o-2N.3.2”,”0-u-2O.3.2”,”0-u-2w.3.2”,”0-D-2x.3.2”,”0-D-2t.3.2”,”0-z-2u.3.2”,”0-z-2z.3.2”,”0-y-2D.3.2”,”0-y-2F.3.2”,”0-7-2A.3.2”,”0-7-2C.3.2”,”0-5-2T.3.2”,”0-5-3b.3.2”,”0-4-3c.3.2”,”0-4-39.3.2”,”0-g-3d.3.2”,”0-g-3h.3.2”,”0-i-3j.3.2”,”0-i-3f.3.2”,”0-b-3g.3.2”,”0-b-2X.3.2”,”0-d-2Z.3.2”,”0-d-2V.3.2”,”0-11-2W.3.2”,”0-11-34.3.2”,”0-13-35.3.2”,”0-13-31.3.2”,”0-10-32.3.2”,”0-10-1J.3.2”,”0-15-1O.3.2”,”0-15-1P.3.2”,”0-1d-1R.3.2”,……………………………………,’M4UxFsAsB9odxAIwA7WQOwObQAwCYBWXPAFlwHYBmY6ncousuvYgDlwDZ38BOT8zn3wcKARmICKOXK1qsmrFjlHdRAnKxEb1rBqK2ih5dSSbkteJXnEbpGm+SF47HLZSEElBOwRsEmlOqU3AS0JHYkWiRKJAwkYTYkQiQmIQwcShy0HDaUSpQuDJQ2HAG0BEFFWgTVQhw+3JRMOEw8Shq4PK……………………………………..GHXTzLjxjzN5CziB+3ODSAhicwuCyeBJ3YJD+eKhEi83fHm76PmK3Y/htPJFzw8LzOCqKTMcXGHr7Jm/nlPtuSUfPBAA===’‘\x73\x70\x6c\x69\x63’,0,{})) </script>

为了节省篇幅，我把一些替换成…….了。如果你对这些数据的解压有兴趣，请后台联系我。 我第一眼看见时，做了 2 件事： 1、把[\x65\x76\x61\x6c]，[ \x73\x70\x6c\x69\x63]，[\x7c]分别解码，解码出的结果为 eval 和 splic，| ； 注：其实这里看到 eval 时就应该想到可以试试直接用 pyexecjs 执行后面的那段 js 匿名函数，但是当时确实啥都没有想起来，很惭愧，后来复盘时才发现这一点。虽然执行了也会报错。 2、把那一长串的字母试着用 base64 解码了，但是解不出来； 然后，就只能再去其他 js 文件里找了，也找到了 js 代码，打了断点，但是看着还是很烦，于是这个时候我就没有在 js 上面死抠。 接着，我调转了方向，在 GITHUB，Google 运用了我祖传的高级搜索技巧，Finally，终于可以盘它了。

二、解密

下面开始解密： 1、数据解压 包含 A===的字符串到底时啥呢，其实这个是 js 的一种数据的压缩方式，知道了这种方式你就可以立即破解这种反爬虫机制了，反正我以前是不知道的，第一次见到，学习了。 在这里，lzstring 闪亮登场，运用这个库，执行下面的代码：

lzstring.LZString().decompressFromBase64(string)

这样就可以把上面的那串字符给解码了，解出来的数据像下面这样：

webp|png|025|024|073

没错，数据解压就是这么的简单； 2、看懂 JS 我们在上面解码出来了一个 splic 和一个[ | ]，再看看我们上面解压出来的数据，是不是很有感觉；但是，查了好一会资料，也没有发现 js 里面有这个方法，可能是在别的地方定义了；在我找到的资料里面，那个作者是直接用了 split，最后的结果是对的，走逻辑上也说得过去，不知道为什么这么设置成 splic，还希望有大神可以指教； 3、执行 JS 所以，到这里就很明显了，把解码以后以及解压以后的数据在替换会原 js 数据中，我们前面解码出来的 eval 就有用了，我找到的资料里面作者使用 node 做的，我没有安装 node 环境，所以我就直接用了 pyexecjs.eval 直接执行了，结果也正确； 4、梳理流程： 匹配长字符串==>lzstring 解压+解码后的字段==>拼凑成新的 js 代码==>pyexecjs 执行==>出结果 5、部分代码 执行的主要步骤和结果

execjs.eval(res)

没错，就是这么简单，res 就是替换后的 js，然后就可以直接出来我们上面网址中需要的两个字段了。 截个图吧

三、结语

到这里，今天的文章就结束了，总结一下就是知道了一种 JS 数据的压缩方式，并且学习了解压的方式，JS 的执行，同时写代码的时候**多观察，多想，多试**。 如果觉得还不错，欢迎动动手指关注我。

大家好，我是四毛，好久没有写东西了，欢迎大家关注我的公众号。

今天的文章是关于如何使用 requests 来爬取大众点评的数据。 看完本文，你可以：

1、了解大众点评的 CSS 反爬虫机制 2、破解反爬虫机制 3、使用 requests 即可正确获取到评论数，平均价格，服务，味道，环境数据，评论文本数据；

如果你想跟我继续交流的话，欢迎加我的个人微信，二维码在最后。 如果你想获取更多的代码，请关注我的公众号，并发送 “大众点评”即可。 同时，代码我并没有做太多的优化，因为没有大量的代理，爬不了太多的内容。 这里只是跟大家分享一下处理的流程。欢迎来公众号留言探讨。

正文开始。

1.前言

在工作生活中，发现越来越多的人对大众点评的数据感兴趣，而大众点评的反爬又是比较严格的。采取的策略差不多是宁可错杀一万，也不放过一个。有的时候正常浏览都会跳出验证码。 另外，在 PC 端的展示数据是通过 CSS 来控制的，从网页上看不出来太大的区别，但是用普通的脚本取获取时，会发现数据是获取不到的，具体的源代码是下面这样的： 然，在搜资料的时候，你会发现，很多教程都是用的 selenium 之类的方法，效率太低，没有啥技术含量。 所以，这篇文章的面向的对象就是 PC 端的大众点评；目标是解决这种反爬虫措施，使用 requests 获取到干净正确的数据； 跟着我，绝不会让你失望。

2.正文开始

相信搞过大众点评网站的同学都应该知道上面的这种是一个 css 反爬的方法，具体的解析操作，即将开始。

找到藏着秘密的 css

当我们的鼠标在上面框框内的 span 上面点击时，会发现右边部分会相应的发生变化： 这张图片很重要，很重要，很重要，我们要的值，几乎都从这里匹配出来。 这里我们看到了“vxt20”这个变量对应的两个像素值，前面的是控制用哪个数字，后面的是控制用哪一段的数字集合，先记下，后面要用，同时这里的值应该是 6； 这里其实就是整个破解流程最关键的一步了。在这里我们看到了一个链接。 瞎猫当死耗子吧，点进去看看。 https://s3plus.meituan.net/v1/mss_0a06a471f9514fc79c981b5466f56b91/svgtextcss/f556c0559161832a4c6192e097db3dc2.svg 你会发现，返回的是一些数字，我一开始是不知道这是啥玩意的，看过一些大神的解析才知道，其实这里就是我们看到的数字的来源，也就是整个破解的源头，知道了这些数字的含义，也就可以直接破解了整个反爬的流程。 现在直接看源代码： 可以看到这里面的几个关键数字：font-size：字体大小；还有几个 y 的值，我到后面才知道原来这个 y 是个阈值，起的是个控制的作用。 所以，这一反爬的原理就是：

获取属性值与偏移量和阈值映射，然后从 svg 文件中找到真数据。

现在我们就要用到上面的像素值了。

1.把所有的值取绝对值； 2.用后面的值来选择用哪个段的数字，这里的值是 103，所以使用第三个段的数字集合； 3.因为每个字体是 12 个像素，所以用 163/12=13.58，约等于 14，那么我们数一下第 14 个数字是啥，没错，是 6，和预期一样。你可以多试验几次。

以上，就是整个破解的逻辑过程。 画个流程图，装个逼：

3.Show Code

下面开始晒代码，俗话说得好，天下代码一大抄。 这里对主要的步骤代码进行解释， 如果你想获取更多的代码，请关注我的公众号，并发送 “大众点评”即可。。 1.获取 css_url 及 span 对应的 TAG 值；

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

def get_tag(_list, offset=1):
    # 从第一个开始查
    _new_list = [data[0:offset] for data in _list]

    if len(set(_new_list)) == 1:
        # 如果set后只有一个值，说明全部重复，这个时候就把offset加1
        offset += 1
        return get_tag(_list, offset)
    else:
        _return_data = [data[0:offset - 1] for data in _list][0]

        return _return_data

def get_css_and_tag(content):
    """
    :param url: 待爬链接
    :return: css链接，该span对应的tag
    """
    find_css_url = re.search(r'href="([^"]+svgtextcss[^"]+)"', content, re.M)
    if not find_css_url:
        raise Exception("cannot find css_url ,check")
    css_url = find_css_url.group(1)

    css_url = "https:" + css_url
    # 这个网页上不同的字段是由不同的css段来进行控制的，所以要找到这个评论数据对应的tag，在这里返回的值为vx；而在获取评论数据时，tag就是fu-;
    # 具体可以观察上面截图的3个span对应的属性值，相等的最长部分为vx
    class_tag = re.findall("<b class=\"(.*?)\"></b>", content)
    _tag = get_tag(class_tag)

    return css_url, _tag

2.获取属性与像素值的对应关系

1
2
3
4
5
6
7
8
9
10
11
12
13

def get_css_and_px_dict(css_url):
    con = requests.get(css_url, headers=headers).content.decode("utf-8")
    find_datas = re.findall(r'(\.[a-zA-Z0-9-]+)\{background:(\-\d+\.\d+)px (\-\d+\.\d+)px', con)
    css_name_and_px = {}
    for data in find_datas:
        # 属性对应的值
        span_class_attr_name= data[0][1:]
        # 偏移量
        offset = data[1]
        # 阈值
        position = data[2]
        css_name_and_px[span_class_attr_name] = [offset, position]
    return css_name_and_px

3.获取 svg 文件的 url

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

def get_svg_threshold_and_int_dict(css_url, _tag):
    con = requests.get(css_url, headers=headers).content.decode("utf-8")
    index_and_word_dict = {}
    # 根据tag值匹配到相应的svg的网址

    find_svg_url = re.search(r'span[class\^="%s"].*?background\-image: url\((.*?)\);' % _tag, con)
    if not find_svg_url:
        raise Exception("cannot find svg file, check")
    svg_url = find_svg_url.group(1)
    svg_url = "https:" + svg_url
    svg_content = requests.get(svg_url, headers=headers).content
    root = H.document_fromstring(svg_content)
    datas = root.xpath("//text")
    # 把阈值和对应的数字集合放入一个字典中
    last = 0
    for index, data in enumerate(datas):
        y = int(data.xpath('@y')[0])
        int_data = data.xpath('text()')[0]
        index_and_word_dict[int_data] = range(last, y+1)
        last = y
    return index_and_word_dict

4. 获取最终的值

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

def get_data(url ):
    """
    :param page_url: 待获取url
    :return:
    """
    con = requests.get(url, headers=headers).content.decode("utf-8")
    # 获取css url，及tag
    css_url, _tag = get_css(con)
    # 获取css对应名与像素的映射
    css_and_px_dict = get_css_and_px_dict(css_url)
    # 获取svg的阈值与数字集合的映射
    svg_threshold_and_int_dict = get_svg_threshold_and_int_dict(css_url, _tag)

    doc = etree.HTML(con)
    shops = doc.xpath('//div[@id="shop-all-list"]/ul/li')
    for shop in shops:
        # 店名
        name = shop.xpath('.//div[@class="tit"]/a')[0].attrib["title"]
        print name
        comment_num = 0

        comment_and_price_datas = shop.xpath('.//div[@class="comment"]')
        for comment_and_price_data in comment_and_price_datas:
            _comment_data = comment_and_price_data.xpath('a[@class="review-num"]/b/node()')
            # 遍历每一个node，这里node的类型不同，分别有etree._ElementStringResult(字符)，etree._Element（元素），etree._ElementUnicodeResult（字符）
            for _node in _comment_data:
                # 如果是字符，则直接取出
                if isinstance(_node, etree._ElementStringResult):
                    comment_num = comment_num * 10 + int(_node)
                else:
                    # 如果是span类型，则要去找数据
                    # span class的attr
                    span_class_attr_name = _node.attrib["class"]
                    # 偏移量，以及所处的段
                    offset, position = css_and_px_dict[span_class_attr_name]
                    index = abs(int(float(offset) ))
                    position = abs(int(float(position)))
                    # 判断
                    for key, value in svg_threshold_and_int_dict.iteritems():
                        if position in value:
                            threshold = int(math.ceil(index/12))
                            number = int(key[threshold])
                            comment_num = comment_num * 10 + number
            print comment_num

4.结果展示

评论条数数据

其实，其他的我都写好了，就不贴了

评论具体数据

5.结语

以上就是大众点评 Css 反爬破解的全部步骤和部分代码。 如果你想获取更多的代码，请关注我的公众号，并发送 “大众点评”即可。

最近一段时间没有更新原创文章了，主要是因为最近整个在忙硕士毕业的各种事情，毕业答辩完了以后休假了一小段时间，整个十二月就这么过去了。 转眼已经 2019 年了，其实去年我并没有写年终总结，现在到头来还是蛮后悔的，说实话总结其实还是蛮有必要的，现在就趁着这个时间来对自己的 2018 做一下总结，并立一下 2019 的一些 Flag，再等到 2020 年翻出来打脸吧。 世界上最了解自己的人当然是自己，一句话总结我的 2018 可以说是： 成就不算少，进步不算多 的一年。为什么成就不算少呢？因为今年可能发生的事相比我之前几年，自己取得了一些从未有的成就，或者完成了一些比较重要的事情。下面就先总结一下自己取得的一些成就吧： 1. 2018 年中出版了自己人生中第一本书籍作品《Python3网络爬虫开发实战》，半年多时间现在已经累计印刷九次，共计 45000 册，上市初长期处在京东科技新书榜第一位的位置，豆瓣评分 9.2。 2. 2018 年 1 月 20 日正式开始运营自己的个人公众号“进击的Coder”，发布了两百多篇文章，其中大约一半为原创，粉丝现在是 25000 多人。 3. 发布了自己开发的一款分布式网络爬虫管理框架 Gerapy，可以完成爬虫项目的配置、部署、管理、监控等功能，目前 GitHub 上 Star 数目将近 1000。 4. 在 GitHub 上创建和贡献了近 100 个项目，目前个人 Followers 达到 3000 人，收获 Star 数目在 2000 左右。 5. 开始从事机器学习、深度学习方向的研究和开发，并发布了自己开发的一套深度学习脚手架 ModelZoo，并不断对接各种模型，持续完善中。 6. 比较顺利地完成秋招，并最终拿到了微软的 Offer，达成理想的结果。 7. 完成了多次大型公开演讲并结识了许多优秀的业界大佬。 8. 顺利地完成了毕业论文和毕业答辩，成功取得北航硕士学位。 9. 凭借自己赚得人生第二桶金，实现收入翻番。 10. Last but not least，她。 当然还有一些其他的就不再一一列举了。这些可能有的跟一些大佬比起来可能真的是小巫见大巫，不过对我来说，这些成就我总体还是比较满意的。 在这些成就里，有些是真的改变我人生轨迹的事情，有些可能只是我人生路顺理成章踏过去的事情，有的可能只是昙花一现几年后毫无价值的东西。但拿掉其中一个，不管是看似有用或者没用的，也可能会产生意想不到的影响，他们确实是我真实经历过，并出现在我生命旅途中的一部分。 本来把成就一个个地展开来说，但后来想想没这个必要。昨日取得的成就就让它过去吧，不要念过去，把更多的精力着眼在未来吧。重要的在于，我在这一年里收获了多少，这些收获的东西能够为我未来的成长带来多少价值。以及另外重要的是，对过去的反思，我还有哪些做的不好的地方，我需要在未来做怎样的调整。 所以为什么说进步不算多呢？虽然自己达成了某些目标，但我真的没怎么感觉到自己相比去年年初的自己有特别大的成长，或许一切都是潜移默化的，或许真的把我现在放回到 2018年初，和现在的自己相比，我才会感觉到差别，但现在自己仿佛真的感觉自己本身和之前没有太多不同。但总的来说，我还有非常多需要反思和改进的地方。 下面再好好反思下自己吧，我总觉得自己的这一年，自己的有些方面做得不够好，总体体现在这么几个方面吧： 1. 拖延症。还是觉得自己的拖延症太严重，执行力还不够好。有些事总是会拖个好几天才完成，没太有恒心。或者有的时候这件事到了要做的时间，却又不想做。之前也会有，但是感觉今年犯的很严重。其实我挺佩服那些持之以恒的人的，自制力和执行力真的很重要。 2. 记录少。挺多自己觉得会的东西，由于懒或者忙，没有记下来，其实还是因为懒。到头来发现真正学会的其实仅仅就是自己记录的部分，因为当时没做记录的，又忘得一干二净了。所以我总体感觉，今年输出的文章并不多。 3. 白忙活。这一年来，其实回想起来，感觉做的无用功是很多了。许多事情感觉做完了之后，真正的价值并不大，所以这个真的需要我来好好权衡。 4. 虎头蛇尾。由于自己的很多事情安排的满满当当，所以有的项目可能就容易被搁置了，导致有一些项目做得虎头蛇尾，草草收场，想想还是很可惜的，但有时候就是缺乏那重新捡起来的一步动力，这个必须得改。 5. 时间规划。我使用 Todoist 已经好多年了，感谢它帮我完成了大部分的时间规划，但有些时候发现还是有些不够好。我多少还会有一些小事优先，大事拖延的倾向，但总体来说已经把握得还算可以了，还得继续加油。 6. 缺乏锻炼。平时事情安排的挺多，有时候也懒得去健身房锻炼，唯一锻炼的时间就是睡前的几分钟了，但是效果不大。可能偶尔一时兴起会去几次健身房，但是还是难以坚持下来。虽然还没感觉到身体有啥不适，但也得加强锻炼了。 所以总体感觉下来，感觉到自己做的不够好的地方还有很多，或许真的要改正对我来说真的挺难，但我也要尽力去做的更好。 这一年中，领悟或贯彻的一些理念也不少，其实太多太多，在这里也不能一一列举了，这里就把现在想到的一些说一下吧： 1. 做一件事前，想想这件事的意义和成本有多大，别把时间浪费在无意义的事情上面。 2. 记录和总结真的很重要。别以为自己当时记住了，等回过头来，你有时候会发现自己的收获就是你所记录的那一部分，没有记录的你想也想不起来了。 3. 如果自己没本事，认识很多牛人，没什么太大意义，重要的还是自己要牛逼，多投资自己。自己牛逼了，别人就都会看到你了。 4. 成年人、社会人的世界，有太多大家都已经默认的规矩，自己要去懂，没几个人会教你。 5. 钱，不能保证能买到所有东西，但是它的确可以提供便利或者免去不必要的麻烦。它是可以增加幸福感的。 6. 如果想要赚钱，最好不要选和时间或精力成正比的事情，多考虑复利。 7. 如果一件东西，花了钱，买到的又不是达到自己预期的，这是双亏。如果买到的是自己所满意或喜欢的的，这就是值的。 8. 选择比努力很重要，眼界比本事更重要。 9. 所有的一切，如果有能力，就不要将就，可能一时由于自己的能力还无法改变，但一定不要丢了改变下去的动力。 10. 如果一件事是自己不喜欢的但是非要做，那就用最短的时间去完成。 11. 健康第一。 还有很多，就暂且写这些吧。这是我现阶段所领悟到的一些东西，也是我成长路上的一种认知转变过程吧。也可能再过几年我就不会这么想了。不过现阶段我会秉承这些理念继续前行。 最后就立几个 2019 年的 Flag 吧（等明年翻出来打脸： 1. 踏入社会和职场的第一年，好好工作，把握好节奏。 2. 完成《Python3网络爬虫开发实战（第二版）》以及现在初步规划的另外的两部作品（名称尚未完全确定暂不透露。 3. 微信公众号读者粉丝在 2019 年底达到 10 万。 4. 自己的 Gerapy、ModelZoo 两个项目持续运营维护，力求完善。 5. 坚持记录，持续输出（内容规划了挺多），达到自己内心中设定的基本目标。 6. 2019 年年收入比 2018 年继续翻番。 7. 结识更多的人，扩展更广的人脉。 8. Last but not least，和她好好地在一起，过我们的向往的生活，做喜欢的事情。 好啦，感谢大家一直以来的支持！新的一年，继续努力！愿我们都成为更好的自己！

Hello 各位小伙伴 雷门吼！

在教程之前首先申明！此教程适合土豪不缺钱的玩家

潜水了许久了，今天来更新点东西~ 今天说点啥呢？ 那就是代理！！ 代理在爬虫界的重要作用相信各位应该清楚吧！毕竟绝大部分反爬可以靠代理解决；不能被代理解决的也得要代理配合解决。 市面上各种代理也是琳琅满目的说··· 相信大家最喜欢用的之一应该就是 某布云。 根据官网的显示他他家的代理是这个样子的：

• 无须切换 IP，每一个请求一个随机 IP。

哇！感觉很爽的样子今天我们就来实现一个类似的代理！ 其实 So Easy！ 我们需要借助 公有云 来实现。 下面我以 AWS 举例(其它公有云操作类似，唯一的区别的就是：各个服务的名字不同而已)

1. 首先我们需要需要使用 EC2 来建立一个代理（Google Could 叫 GCE）
   1. 安装 Squid（当然你可以使用其它的代理）
      1. 无认证安装参考这儿(点我)设置代理服务器那一段
      2. MySQL 认证安装(点我)
      3. Note: 请注意检查！！！务必设置 Ipv4 转发
2. 安装完成之后我们制作启动模板（毕竟一个 EC2 一个 IP 你总不能安装很多很多台吧！会死人的）
   1. 注意设置你的安全组！正常情况下 入站规则只应该有你需要的端口（squid 使用的端口一定要放心！嫌麻烦的小伙伴儿 可以进出都放行全部流量！）出站则是全部流量！
   2. 启动 EC2 的时候选择安全组一定要看清是否是设置过放行的规则！ 不要选错了！
   3. 
   4. 
   5. 
   6. 好了现在就可以批量启动了！
   7. 实例数量就是需要同时有多少个 IP 就启动多少个了。
   8. 
3. 设置前端负载均衡（提供一个固定地址，这个地址负责随机将请求转发到后端代理服务器上）
   1. 
   2. 必须使用 TCP 四层负载！原因为啥大家自己百度一哈
   3. 
   4. 
   5. 
   6. 等待负载均衡器启动完成！
   7. 启动完成后获取负载地址
4. 下面来测试一下效果！
   1. 

以上完毕！你可以不停的重启 Ec2 实例！你就有百万 IP 池啦！！（前提是你有钱啊） 下面是重启 Ec2 的示例：

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

import boto3
from boto3 import setup_default_session


setup_default_session(aws_access_key_id='XXXXXX',
                      aws_secret_access_key='XXXXXX',
                      region_name='区域')

ec2 = boto3.client('ec2')


def get_public_ip_address():
    """
    获取IP和实例ID
    :return: {实例ID: ip}
    """
    response = ec2.describe_instances()
    reservations = response.get('Reservations')
    instances = [i.get('Instances')[0] for i in reservations]
    instance_id_public_ip_address = {i.get('InstanceId'): i.get('PublicIpAddress') for i in instances}
    return instance_id_public_ip_address


def reboot_ec2(ip):
    """重启实例
    :param ip:
    :return:
    """
    instance_id_public_ip_address = get_public_ip_address()
    instance_id = instance_id_public_ip_address.get(ip)
    try:
        ec2.reboot_instances(InstanceIds=[instance_id], DryRun=True)
    except ClientError as e:
        if 'DryRunOperation' not in str(e):
            print("You don't have permission to reboot instances.")
            raise

    try:
        response = ec2.reboot_instances(InstanceIds=[instance_id], DryRun=False)
        print('Success', response)
    except ClientError as e:
        print('Error', e)

前言

随着大数据时代的到来，爬虫已经成了获取数据的必不可少的方式，做过爬虫的想必都深有体会，爬取的时候莫名其妙 IP 就被网站封掉了，毕竟各大网站也不想自己的数据被轻易地爬走。 对于爬虫来说，为了解决封禁 IP 的问题，一个有效的方式就是使用代理，使用代理之后可以让爬虫伪装自己的真实 IP，如果使用大量的随机的代理进行爬取，那么网站就不知道是我们的爬虫一直在爬取了，这样就有效地解决了反爬的问题。 那么问题来了，使用什么代理好呢？这里指的代理一般是 HTTP 代理，主要用于数据爬取。现在打开搜索引擎一搜 HTTP 代理，免费的、付费的太多太多品牌，我们该如何选择呢？看完这一篇文章，想必你心中就有了答案。 对于免费代理，其实想都不用想了，可用率能超过 10% 就已经是谢天谢地了。真正靠谱的代理还是需要花钱买的，那这么多家到底哪家可用率高？哪家响应速度快？哪家比较稳定？哪家性价比比较高？为此，我对市面上比较流行的多家付费代理针对可用率、爬取速度、爬取稳定性、价格、安全性、请求限制等做了详细的评测，让我们来一起看一下到底哪家更强！

测评范围

免费代理

在这里我主要测试的是付费代理，免费代理可用率太低，几乎不会超过 10%，但为了作为对比，我选取了西刺免费代理进行了测试。

付费代理

付费代理我选取了站大爷、芝麻 HTTP 代理、太阳 HTTP 代理、讯代理、快代理、蘑菇代理、阿布云代理、全网代理、云代理、大象代理、多贝云进行了对比评测，购买了他们的各个不同级别的套餐使用同样的网络环境进行了测评，详情如下：

注：其中蘑菇代理、太阳 HTTP 代理、芝麻 HTTP 代理的默认版表示此网站只有这一种代理，不同套餐仅是时长区别，代理质量没有差别。 嗯，我把上面的套餐全部买了一遍，以供下面的评测使用。

测评目标

本次测评主要分析代理的可用率、响应速度、稳定性、价格、安全性、使用频率等因素，下面我们来一一进行说明。

可用率

可用率就是提取的这些代理中可以正常使用的比率。假如我们无法使用这个代理请求某个网站或者访问超时，那么就代表这个代理不可用，在这里我的测试样本大小为 500，即提取 500 个代理，看看里面可用的比率多少。

响应速度

响应速度可以用耗费时间来衡量，即计算使用这个代理请求网站一直到得到响应所耗费的时间。时间越短，证明代理的响应速度越快，这里同样是 500 个样本，计算时只对正常可用的代理做统计，计算耗费时间的平均值。

稳定性

由于爬虫时我们需要使用大量代理，如果一个代理响应速度特别快，很快就能得到响应，而下一次请求使用的代理响应速度特别慢，等了三十秒才得到响应，那势必会影响爬取效率，所以我们需要看下商家提供的这些代理稳定性怎样，总不能这一个特别快，下一个又慢的不行。所以这里我们需要统计一下耗费时间的方差，方差越大，证明稳定性越差。

价格

价格，这个当然是需要考虑的内容，如果一个代理不论是响应速度还是稳定性都特别不错，但是价格非常非常高，这也是不可接受的。

安全性

这的确也是需要考虑的因素，比如一旦不小心把代理提取的 API 泄露出去了，别人就肆意使用我们的 API 提取代理使用，而一直耗费的是我们的套餐。另外一旦别人通过某些手段获取了我们的代理列表，而这些代理是没有安全验证的，这也会导致别人偷偷使用我们的代理。在生产环境上，这方面尤其需要注意。

使用频率

有些代理套餐在 API 调用提取代理时有频率限制，有的代理套餐则会限制请求频率，这些因素都会或多或少影响爬虫的效率，这部分因素我们也需要考虑进来。

测评标准

要做标准的测评，那就必须在标准的测评环境下进行，且尽可能排除一些杂项的干扰，如网络波动、传输延迟等一系列的影响。

主机选取

由于我的个人笔记本是使用 WiFi 上网的，所以可能会有网络波动，而且实际带宽其实并不太好把控，因此它并不适合来做标准评测使用。评测需要在一个网络稳定的条件下进行，而且多个代理的评测环境必须相同，在此我选择了一台腾讯云主机作为测试，主机配置如下：

这样我们就可以保证一个标准统一的测试环境了。

现取现测

另外在评测时还需要遵循一个原则，那就是现取现测，即取一个测一个。现在很多付费代理网站都提供了 API 接口，我们可以一次性提取多个代理，但是这样会导致一个问题，每个代理在提取出来的时候，商家是会尽量保证它的可用性的，但过一段时间，这个代理可能就不好用了，所以假如我们一次性提取出来了 100 个代理，但是这 100 个代理并没有同时参与测试，后面的代理就会经历一个的等待期，过一段时间再测这些代理的话，肯定会影响后半部分代理的有效性，所以这里我们将提取的数量统一设置成 1，即请求一次接口获取一个代理，然后立即进行测试，这样可以保证测试的公平性，排除了不同代理有效期的干扰。

时间计算

由于我们有一项是测试代理的响应速度，所以我们需要计算程序请求之前和得到响应之后的时间差，这里我们使用的测试 Python 库是 requests，所以我们就计算发起请求和得到响应之间的时间差即可，时间计算方法如下所示：

1
2
3
4

start_time = time.time()
requests.get(test_url, timeout=timeout, proxies=proxies)
end_time = time.time()
used_time = end_time - start_time

这里 used_time 就是使用代理请求的耗时，这样测试的就仅仅是发起请求到得到响应的时间。

测试链接

测试时我们也需要使用一个稳定的且没有反爬虫的链接，这样可以排除服务器的干扰，这里我们使用百度来作为测试目标。

超时限制

在测试时免不了的会遇到代理请求超时的问题，所以这里我们也需要统一一个超时时间，这里设置为 60 秒，如果使用代理请求百度，60 秒还没有得到响应，那就视为该代理无效。

测试数量

要做测评，那么样本不能太小，如只有十几次测试是不能轻易下结论的，这里我选取了一个适中的测评数量 500，即每个套餐获取 500 个代理进行测试。

测评过程

嗯，测评过程这边主要说一下测评的代码逻辑，首先测的时候是取一个测一个的，所以这里定义了一个 test_proxy() 方法：

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

test_url = 'https://www.baidu.com/'
timeout = 60

def test_proxy(proxy):
    try:
        proxies = {
            'https': 'http://' + proxy
        }
        start_time = time.time()
        requests.get(test_url, timeout=timeout, proxies=proxies)
        end_time = time.time()
        used_time = end_time - start_time
        print('Proxy Valid', 'Used Time:', used_time)
        return True, used_time
    except (ProxyError, ConnectTimeout, SSLError, ReadTimeout, ConnectionError):
        print('Proxy Invalid:', proxy)
        return False, None

这里需要传入一个参数 proxy，代表一个代理，即 IP 加端口组成的代理，然后这里使用了 requests 的 proxies 参数传递给 get() 方法。对于代理无效的检测，这里判断了 | ProxyError, ConnectTimeout, SSLError, ReadTimeout, ConnectionError 这几种异常，如果发生了这些异常统统视为代理无效，返回错误。如果在 timeout 60 秒内得到了响应，那么就计算其耗费时间并返回。 在主程序里，就是获取 API 然后统计结果了，代码如下：

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

max = 500

def main():
    print('Testing')
    used_time_list = []
    valid_count = 0
    total_count = 0
    while True:
        flag, result = get_page(api_url)
        if flag:
            proxy = result.strip()
            if is_proxy(proxy):
                total_count += 1
                print('Testing proxy', proxy)
                test_flag, test_result = test_proxy(proxy=proxy)
                if test_flag:
                    valid_count += 1
                    used_time_list.append(test_result)
                stats_result(used_time_list, valid_count, total_count)
        time.sleep(wait)
        if total_count == max:
            break

这里加了一些判断，如 is_proxy() 方法判断了获取的是不是符合有效的代理规则，即判断它是不是 IP 加端口的形式，这样可以排除 API 返回一些错误信息的干扰。另外这里设置了 total_count 和 valid_count 变量，只有符合代理规则的代理参与了测试，这样才算一次有效测试，total_count 加一，如果测试可用，那么 valid_count 加一并记录耗费时间。最后调用了 stats_results 方法进行了统计：

1
2
3
4
5
6
7
8
9
10
11

import numpy as np

def stats_result(used_time_list, valid_count, total_count):
    if not used_time_list or not total_count:
        return
    used_time_array = np.asarray(used_time_list, np.float32)
    print('Total Count:', total_count,
          'Valid Count:', valid_count,
          'Valid Percent: %.2f%%' % (valid_count * 100.0 / total_count),
          'Used Time Mean:', used_time_array.mean(),
          'Used Time Var', used_time_array.var())

这里使用了 Numpy 来统计了耗费时间的均值和方差，分别反映代理的响应速度和稳定性。 嗯，就这样，利用这个方法我对各个不同的代理套餐逐一进行了测试。

测评结果

经过测评，初步得到如下统计结果：

注：

• 表中的响应时间方差越大，代表稳定性越低。
• 阿布云代理经典版方差较小是因为它是长时间锁定了同一个 IP，因此极其稳定，但每秒最大请求默认 5 次。
• 多贝云代理套餐一二方差较小是因为它是长时间锁定了同一个 IP，因此极其稳定，但每秒最大请求默认 20 次。

测评分析

下面我们将从各个方面分析一下各个套餐的优劣。

可用率

通过可用率统计，我们可以发现可用率较高的代理套餐有：

响应速度

通过平均响应速度判别，我们可以发现响应速度较快的代理套餐有：

稳定性

通过平均响应速度方差分析，我们可以发现稳定性较高的代理套餐有：

价格

我们可以看一下各个套餐的价格：

安全性

对于安全性，此处主要考虑提取 API 是否有访问验证，使用代理时是否有访问验证，即可以通过设置白名单来控制哪些可以使用。 其中只有芝麻 HTTP 代理、太阳 HTTP 代理默认使用了白名单限制，即只有将使用 IP 添加到白名单才可以使用，可以有效控制使用权限。 另外阿布云代理提供了隧道代理验证，只有成功配置了用户名和密码才可以正常使用。 所以在此归纳如下：

调取频率

不同的接口具有不同的 API 调用频率限制，归纳如下：

在此可以简单总结如下：

级别

特色功能

除了常规的测试之外，我这边还选取了某些套餐的与众不同之处进行说明，这些特点有的算是缺点，有的算是优点，现列举如下：

测评综合

分项了解了各个代理套餐的可用率、响应速度、稳定性、性价比、安全性等内容之后，最后做一下总结：

所以在综合来看比较推荐的有：芝麻代理、快代理、讯代理、阿布云、多贝云代理，详细的对比结果可以参照表格。 以上便是各家代理的详细对比测评情况，希望此文能够在大家选购代理的时候有所帮助。

大家好，我是四毛，下面的是我的公众号，欢迎关注。

今天的内容主要讲的是破解一个网站的 rsa 加密，当然肯定不是破解这个算法，而是找到加密的参数，正确模拟这个算法即可。

1. 什么是 rsa 算法

下面的资料摘抄自阮一峰老师的文章， 点这里了解更多 1976 年，两位美国计算机学家 Whitfield Diffie 和 Martin Hellman，提出了一种崭新构思，可以在不直接传递密钥的情况下，完成解密。这被称为“Diffie-Hellman 密钥交换算法”。这个算法启发了其他科学家。人们认识到，加密和解密可以使用不同的规则，只要这两种规则之间存在某种对应关系即可，这样就避免了直接传递密钥。 这种新的加密模式被称为”非对称加密算法”。

（1）乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。 （2）甲方获取乙方的公钥，然后用它对信息加密。 （3）乙方得到加密后的信息，用私钥解密。

如果公钥加密的信息只有私钥解得开，那么只要私钥不泄漏，通信就是安全的。

2. 研究目标

从我要研究的网站来说，就是根据参数得到正确的公钥，加密以后返回给服务器，让服务器使用私钥可以解密出正确的数据即可。 同时，本文不会将具体的网站说出来，只是给大家提供一个解决问题的思路。

3. 开始

3.1 抓包找参数

首先，打开某个网站的登录页面，输入用户名，密码，验证码之类的参数， 抓包看到了下面这个页面： 我实际输入的值全是 1, 然后都被加密了， 没办法，只能去找加密的方法了。 经过一番搜索过后，才发现，原来加密的算法就在源代码里面，这里截个图： 从这里就可以看到具体的算法名以及相关的参数了，你会说，这是什么算法我都不知道啊？搜啊，用关键词搜一下就能知道了。 同时，是不是觉得这个网站好傻逼，这不太简单了吗？ 肯定不是！！！ 这么简单，说明此处也是必有玄机！！！ 至于什么玄机，到后面说，都是泪。

3.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

# /usr/bin/python
# encoding: utf-8

import base64

def str2key(s):
    # 对字符串解码
    b_str = base64.b64decode(s)

    if len(b_str) < 162:
        return False

    hex_str = ''

    # 按位转换成16进制
    for x in b_str:
        h = hex(ord(x))[2:]
        h = h.rjust(2, '0')
        hex_str += h

    # 找到模数和指数的开头结束位置
    m_start = 29 * 2
    e_start = 159 * 2
    m_len = 128 * 2
    e_len = 3 * 2

    modulus = hex_str[m_start:m_start + m_len]
    exponent = hex_str[e_start:e_start + e_len]

    return modulus,exponent

if __name__ == "__main__":

    pubkey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC7kw8r6tq43pwApYvkJ5laljaN9BZb21TAIfT/vexbobzH7Q8SUdP5uDPXEBKzOjx2L28y7Xs1d9v3tdPfKI2LR7PAzWBmDMn8riHrDDNpUpJnlAGUqJG9ooPn8j7YNpcxCa1iybOlc2kEhmJn5uwoanQq+CA6agNkqly2H4j6wIDAQAB"
    key = str2key(pubkey)
    print key

相应的输出

1
2

('c2ee4c3cafab6ae37a7002962f909e656a58da37d0596f6d530087d3fef7b16e86f31fb43c49474fe6e0cf5c404acce8f1d8bdbccbb5ecd5df6fded74f7ca2362d1ecf033581983327f2b887ac30cda54a499e500652a246f68a0f9fc8fb60da5cc426b58b26ce95cda41219899f9bb0a1a9d0abe080e9a80d92a972d87e23eb',
'010001')

从代码中可以看出，解析了公钥之后得到了两个值，一个就是 010001，和我们在网站源代码里面找到的值是一样的。所以，源代码里面的参数我们应该就是可以直接使用的，是不是有种找到组织的赶脚。 接下来，利用下面的代码，来对数据进行加密

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

import rsa
import binascii
def en_test():
    param_1 = "010001"
    # 某次我找到的
    param_2 = "955120AB9334B7CD52FCDB422DBF564AFD46DEBDC706F33502BBFAD9DD216A22E4D5012CB70F28473B46FB7190D08C31B4B8E76B5112ACE1C5552408961530B1C932DEEA8FC38A9A624AD22073F56F02BF453DD2C1FEA0164106D6B099CC9E5EC88C356FC164FCA47C766DD565D3D11048D27F2DD4221A0B26AB59BD7D09841F"
    message = 'nihao'
    modulus = int(param_2, 16)
    exponent = int(param_1, 16)
    rsa_pubkey = rsa.PublicKey(modulus, exponent)
    crypto = rsa.encrypt(message, rsa_pubkey)
    data = binascii.b2a_hex(crypto)

    print data

if __name__ == '__main__':
    en_test()

但是当我这样做完，进行模拟登录，还以为自己很牛逼的时候，服务器却给我返回了这样的结果， 目瞪狗呆啊：

1

{"Status":false,"ResultValue":"","StatusCode":"REFRESH","StatusMessage":"请尝试重新登录","RecordCount":0,"Data":null}

可以看到信息提示要刷新，但是当时是百思不得其解，为毛线要刷新？ 困惑了一会之后，我再次从头走了一遍流程，这下我才发现，原来源代码里面的那个长长的数据是会改变的，直到这个时候，我才意识到为什么要我刷新。。。。。。 服务器啊，你就不能直接说参数错误吗？刷新你大爷啊。 果然，我还是太年轻啊。

果然，天上掉下的绝不是馅饼，绝逼是个陷阱。

知道这个坑以后就好办了，用个正则匹配一下就行了，而结果也是对的：

1

{"Status":true,"ResultValue":"","StatusCode":"OK","StatusMessage":"成功","RecordCount":0,"Data":{"LoginUrl":"/System/Welcome"}}

4 总结

到这里这篇文章就结束了，这个案例相对于来说很简单，而且为了保护网站的隐私，所以没办法展开说。 有些网站的加密方式是很变态的，比如网易云音乐，知晓常见的加密方法，就可以处理大部分的情况了。 其实，网易云音乐并不是一定要加密， 有想知道非加密的方法的，可以关注我，私聊我。有点敏感，就不写文章了。 反正，我爬了 1000W+的网易云音乐都是不加密的～～ 如果你有类似的问题待解决或者想了解的更清楚的细节的，欢迎关注我的公众号以后，后台私我一下。

最近和几个朋友开发项目，期间使用了一台服务器跑模型，这台服务器是多人公用的，很多人都在上面有自己的账号，互不干涉内政，一切看起来十分井然有序。近期，这个服务器上刚挂载了一块新硬盘，是一位朋友使用 root 账号挂载的，然后将磁盘映射到某个文件夹下。然而挂载好了之后发现使用普通账号没有权限在文件夹下操作，无法创建文件，于是他干脆就直接把文件夹权限改成 777 了。我心想，这还了得，改成 777 了，其他人在里面乱改咋办？会出人命的！所以，我就这件事详细梳理了一下 Linux 下的用户、用户组、文件权限等基本知识，看完这些，以后不要动不动就把文件夹改成 777 权限了。

基本操作

首选我们梳理一下 Linux 下的用户、用户组、文件权限等基本知识，然后后面通过一个案例来实际演示一下权限设置的一些操作。 首先 Linux 系统中，是有用户和用户组的概念的，用户就是身份的象征，我们必须以某一个用户身份来操作一个系统，实际上这就对应着我们登录系统时的账号。而用户组就是一些用户的集合，我们可以通过用户组来划分和统一管理某些用户。 比如我要在微信发一条朋友圈，我只想给我的亲人们看，难道我发的时候还要一个个去勾选所有的人？这未免太麻烦了。为了解决这问题，微信里面就有了标签的概念，我们可以提前给好友以标签的方式分类，发的时候直接勾选某个标签就好了，简单高效。实际上这就是用户组的概念，我们可以将某些人进行分组和归类，到时候只需要指定类别或组别就可以了，而不用一个个人去对号入座，从而节省了大量时间。 在 Linux 中，一个用户是可以属于多个组的，一个组也是可以包含多个用户的，下面我以一台 Ubuntu Linux 为例来演示一下相关的命令和操作。

用户和用户组

首先查看所有用户，命令如下：

1

cut -d':' -f 1 /etc/passwd

结果：

1
2
3
4
5
6
7

root
daemon
bin
sys
...
ubuntu
mysql

这里一行就是一个用户名，由于太多，部分就省略了，实际上这个命令就是从密码文件中把用户名单独列出来了。 然后查看所有用户组，命令也是类似的：

1

cut -d':' -f 1 /etc/group

结果：

1
2
3
4
5
6
7

root
daemon
bin
sys
...
ubuntu
mysql

结果基本是类似的，因为每个用户在被创建的时候都会自动创建一个同名的组作为其默认的用户组。 这里我是使用 ubuntu 这个账号来登录的，下面我来看下 ubuntu 这个账号是属于哪些组。 查看一个用户所属组的命令格式如下：

1

gorups <username>

这里就是 groups 命令加上用户名就能查看该用户名所属的组了，如果不加用户名的话就默认是当前用户。 例如查看 ubuntu 这个用户所属于的组，命令如下：

1

groups ubuntu

结果：

1

ubuntu : ubuntu adm cdrom sudo dip plugdev lxd lpadmin sambashare

还不少，这个用户被分配到了很多组下，比如同名的组 ubuntu，还有 sudo 组，另外还有一些其他的组。 其中 sudo 组比较特殊，如果被分到了这个组里面就代表该账号拥有 root 权限，可以使用 sudo 命令。 了解了怎样查看用户所属的组，我们也应该反过来了解如何查看一个用户组里面包含哪些用户啊。 查看某个用户组下所有用户命令如下：

1

members <group>

不过这个命令不是自带的，需要额外安装 members 包，命令如下：

1

sudo apt-get install members

例如查看 sudo 用户组下的所有用户，即拥有 root 权限的用户：

1

members sudo

结果：

1

ubuntu hadoop

可以看到拥有 root 权限的用户有两个，ubuntu 和 hadoop，当然不同的机器结果肯定是不一样的。 接下来介绍一个比较有用的命令，就是 id 命令，它可以用来查看用户的所属组别，格式如下：

1

id <username>

例如查看 ubuntu 用户的信息，就是这样：

1

id ubuntu

结果：

1

uid=500(ubuntu) gid=500(ubuntu) groups=500(ubuntu),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),110(lxd),115(lpadmin),116(sambashare)

这里有一个 gid，作为主工作组，后面还有个 groups，它列出了用户所在的所有组。主工作组只有一个，而后者的数量则不限。可以看到用户组的结果和使用 groups 命令看到的结果是一致的。 接下来我们再来了解一下如何创建一个用户和怎样为用户分配组别。 添加一个用户命令格式如下：

1

sudo adduser <username>

比如我要添加一个用户 cqc，命令就可以这么写：

1

sudo adduser cqc

这里使用的命令前面都带有 sudo，因为毕竟是系统级别的操作。 添加一个组的命令格式如下：

1

sudo groupadd <group>

格式是类似的，后面跟一个组的名称就可以了，例如我要为我的实验室创建一个用户组，那么就可以使用如下命令：

1

sudo groupadd lab

创建完了用户和组，那得把它们关联起来吧，关联的意思就是把某个用户加入到某个组里面，命令格式如下：

1

sudo adduser <username> <group>

或者使用 usermod 命令：

1

sudo usermod -G <group> <username>

如果要添加多个组的话，可以通过 -a 选项指定多个名称：

1

sudo usermod -aG <group1,group2,group3..> <username>

例如我要将 cqc 用户添加到 sudo 用户组中，命令就是：

1

sudo adduser cqc sudo

或：

1

sudo usermod -G sudo cqc

这样就为用户和用户组做好关联了。

文件权限管理

了解了这些之后，我们再来了解一下文件权限的相关知识，下面我们先随便找一个目录，查看一下文件的列表。 列出某个目录下文件详细信息的命令如下：

1

ll

或者使用：

1

ls -l

比如我这里列出了 /etc/nginx 目录下的文件列表：

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

total 80
drwxr-xr-x   7 root root  4096 Jun 21 22:16 ./
drwxr-xr-x 103 root root  4096 Sep  4 18:04 ../
drwxr-xr-x   2 root root  4096 Jul 12  2017 conf.d/
-rw-r--r--   1 root root  1077 Feb 12  2017 fastcgi.conf
-rw-r--r--   1 root root  1007 Feb 12  2017 fastcgi_params
-rw-r--r--   1 root root  2837 Feb 12  2017 koi-utf
-rw-r--r--   1 root root  2223 Feb 12  2017 koi-win
-rw-r--r--   1 root root  3957 Feb 12  2017 mime.types
-rw-r--r--   1 root root  1505 Jun 21 20:24 nginx.conf
-rw-r--r--   1 root root 12288 Jun 21 20:44 .nginx.conf.swp
-rw-r--r--   1 root root   180 Feb 12  2017 proxy_params
-rw-r--r--   1 root root   636 Feb 12  2017 scgi_params
drwxr-xr-x   2 root root  4096 Jun 21 22:42 sites-available/
drwxr-xr-x   2 root root  4096 Jun 21 19:08 sites-enabled/
drwxr-xr-x   2 root root  4096 Jun 21 19:08 snippets/
-rw-r--r--   1 root root   664 Feb 12  2017 uwsgi_params
drwxr-xr-x   2 root root  4096 Jun 22 02:44 vhosts/
-rw-r--r--   1 root root  3071 Feb 12  2017 win-utf

我们注意到了每一行都是一个文件或文件夹的信息，一共包括七列：

• 第一列是文件的权限信息
• 第二列表示该文件夹连接的文件数
• 第三列表示文件所属用户
• 第四列表示文件所属用户组
• 第五列表示文件大小（字节）
• 第六列表示最后修改日期
• 第七列表示文件名

其中第一列的文件权限信息是非常重要的，它由十个字符组成：

• 第一个字符代表文件的类型，有三种，- 代表这是一个文件，d 代表这是一个文件夹，l 代表这是一个链接。
• 第 2-4 个字符代表文件所有者对该文件的权限，r 就是读，w 就是写，x 就是执行，如果是文件夹的话，执行就意味着查看文件夹下的内容，例如 rw- 就代表文件所有者可以对该文件进行读取和写入。
• 第 5-7 个字符代表文件所属组对该文件的权限，含义是一样的，如 r-x 就代表该文件所属组内的所有用户对该文件有读取和执行的权限。
• 第 8-10 个字符代表是其他用户对该文件的权限，含义也是一样的，如 r— 就代表非所有者，非用户组的用户只拥有对该文件的读取权限。

我们可以使用 chmod 命令来改变文件或目录的权限，有这么几种用法。 一种是数字权限命名，rwx 对应一个二进制数字，如 101 就代表拥有读取和执行的权限，而转为十进制的话，r 就代表 4，w 就代表 2，x 就代表 1，然后三个数字加起来就和二进制数字对应起来了。如 7=4+2+1，这就对应着 rwx；5=4+1，这就对应着 r-x。所以，相应地 777 就代表了 rwxrwxrwx，即所有者、所属用户组、其他用户对该文件都拥有读取、写入、执行的权限，这是相当危险的！ 赋予权限的命令如下：

1

sudo chmod <permission> <file>

例如我要为一个 file.txt 赋予 777 权限，就写成：

1

sudo chmod 777 file.txt

另外我们也可以使用代号来赋予权限，代号有 u、g、o、a 四中，分别代表所有者权限，用户组权限，其他用户权限和所有用户权限，这些代号后面通过 + 和 - 符号来控制权限的添加和移除，再后面跟上权限类型就好，例如：

1

sudo chmod u-x file.txt

就是给所有者移除 x 权限，也就是执行权限。

1

sudo chmod g+w file.txt

就是为用户组添加 w 权限，即写入权限。 另外如果是文件夹的话还可以对文件夹进行递归赋权限操作，如：

1

sudo chmod -R 777 share

就是将 share 文件夹和其内所有内容都赋予 777 权限。 好，有了权限的标识，那我们还得把用户和用户组与文件关联起来啊，这里使用的命令就是 chown 和 chgrp 命令。 命令格式如下：

1
2

sudo chown <username> <file>
sudo chgrp <group> <file>

例如我要将 file.txt 的所有者换成 cqc，那就可以使用如下命令：

1

sudo chown cqc file.txt

如果我要将 file.txt 所属用户组换成 lab，那就可以使用如下命令：

1

sudo chgrp lab file.txt

另外同样可以使用 -R 来进行递归操作，如将 share 文件夹及其内所有内容的所有者都换成 cqc，命令如下：

1

sudo chown -R cqc share/

好，了解了 chown、chgrp、chmod 之后，我们就可以灵活地对文件权限进行控制了。

实战演示

可能上面说起来有点抽象，下面我们以一个实例来演示一下权限控制的流程，通过这个流程，相信理解以上的命令都不在话下了。 首先情况是这样的，我要在某台主机上共享一些文件给我实验室的人，但这台主机上还有其他非实验室的人在使用，我只想让实验室的人查看和修改这些文件，其他人不行。 另外我自己的账号要有最高权限来管理这些文件的共享权限，即要有 root 权限。 现在我已经登录了一个 ubuntu 的账号，是系统初始化的，拥有 root 权限。 下面我就模拟创建三个账号和一个用户组，来得到如下效果：

• 账号 cqc 是我自己使用的账号，拥有最高权限，可以自由调整文件权限信息，可以自由为某个用户分配用户组。
• 账号 lbd 是我实验室的人员，没有 root 权限，但能查看和修改我共享的文件。
• 账号 slb 不是我实验室的人员，没有 root 权限，也不能修改我共享的文件。

创建自己的账户

首先我先为自己创建一个账户，添加一个 cqc 的用户：

1

sudo adduser cqc

运行之后会提示输入密码和其他信息：

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

Adding user `cqc' ...
Adding new group `cqc' (1002) ...
Adding new user `cqc' (1002) with group `cqc' ...
Creating home directory `/home/cqc' ...
Copying files from `/etc/skel' ...
Enter new UNIX password: 
Retype new UNIX password: 
passwd: password updated successfully
Changing the user information for cqc
Enter the new value, or press ENTER for the default
        Full Name []: 
        Room Number []: 
        Work Phone []: 
        Home Phone []: 
        Other []: 
Is the information correct? [Y/n]

这时候发现一个同名的组就被创建了，查看下 cqc 所在的组：

1

groups cqc

结果如下：

1

cqc : cqc

再用 id 命令查看下信息：

1

id cqc

结果如下：

1

uid=1002(cqc) gid=1002(cqc) groups=1002(cqc)

可以看到当前 cqc 只属于 cqc 用户组。 接下来我们创建一个用户组，叫做 lab，来标明我的实验室，命令如下：

1

sudo groupadd lab

然后查看下用户组里面的成员：

1

members lab

没有任何结果，说明我们创建了一个空的组，没有任何成员。 然后我们将刚才创建的 cqc 加入到该组中，因为我自己也属于该实验室，肯定也要加进来，命令如下：

1

sudo adduser cqc lab

结果：

1
2
3

Adding user `cqc' to group `lab' ...
Adding user cqc to group lab
Done.

然后查看下组内成员：

1

members lab

结果：

1

cqc

这样 lab 组内就有了 cqc 这个用户了。 别忘了 cqc 还需要拥有 root 权限，所以我们还需要将 cqc 添加到 sudo 组内，命令如下：

1

sudo adduser cqc sudo

结果：

1
2
3

Adding user `cqc' to group `sudo' ...
Adding user cqc to group sudo
Done.

这样就成功加入到 sudo 组了，cqc 也就是我的账户就可以使用 sudo 命令了。 查看下用户状态：

1

id cqc

结果如下：

1

uid=1002(cqc) gid=1002(cqc) groups=1002(cqc),27(sudo),1003(lab)

这样 cqc 就属于三个用户组了，既是实验室成员，又拥有 root 权限。 上面的分配用户组的命令我们也可以使用 usermod 来实现：

1

sudo usermod -aG sudo,lab cqc

这样就添加到多个组了。

添加实验室用户

接下来，再添加实验室的另外一个人员 lbd，然后将其添加到 lab 组中，流程是类似的，命令如下：

1
2

sudo adduser lbd
sudo adduser lbd lab

运行完毕之后，id 命令查看其信息：

1

id lbd

结果如下：

1

uid=1004(lbd) gid=1005(lbd) groups=1005(lbd),1003(lab)

这样就成功创建 lbd，并将其添加到实验室 lab 组了。

添加非实验室用户

最后另外添加一个用户 slb，非实验室成员，只创建账户就好了，命令如下：

1

sudo adduser slb

但是我们不把他加入 lab 组中。 查看他的状态：

1

id slb

结果如下：

1

uid=1003(slb) gid=1004(slb) groups=1004(slb)

所以三人的状态是这样的：

1
2
3
4
5
6

id cqc
uid=1002(cqc) gid=1002(cqc) groups=1002(cqc),27(sudo),1003(lab)
id lbd
uid=1004(lbd) gid=1005(lbd) groups=1005(lbd),1003(lab)
id slb
uid=1003(slb) gid=1004(slb) groups=1004(slb)

文件权限分配

接下来我们创建一个文件夹来共享实验室数据，放在 /srv 目录下。然后调用 mkdir 命令创建名称为 share 的文件夹，命令如下：

1
2

cd /srv
sudo mkdir share

注意这里我还是使用 ubuntu 账户来创建的。 先看下当前目录权限：

1

ls -l

结果如下：

1
2
3
4

total 12
drwxr-xr-x  3 root root 4096 Sep  4 18:17 ./
drwxr-xr-x 24 root root 4096 Sep  4 18:17 ../
drwxr-xr-x  2 root root 4096 Sep  4 18:17 share/

可以看到 share 文件的所有者是 root，用户组也是 root，权限是 755，即只有 root 拥有修改权限，其他的只有读取和执行权限。 然后进入 share 文件夹创建一个 names.txt：

1
2

cd share
sudo vi names.txt

编辑内容如下：

1
2

cqc
lbd

保存完毕之后，这时查看一下文件权限，如下：

1

-rw-r----- 1 root root    8 Sep  4 20:00 names.txt

权限是 640，这表明只有所有者 root 拥有写入的权限，所在组只有读的权限。 这时开启另外一个终端，登录 cqc 账号，实际上是不能查看和修改任何该文件的内容的，下面的修改和读取命令都会提示权限不够：

1
2

vi names.txt
cat names.txt

为什么呢？因为该文件是刚才由 ubuntu 账号使用 sudo 命令创建的，因此文件的所有者是 root，并不是 cqc，因此即使文件的权限是 640，那也就不能使用文件所有者的权限，而且 cqc 也不属于 root 组，所以也不能使用文件组的权限了，因此什么都看不了，什么都改不了。 但 cqc 属于 sudo 组啊，可以利用 sudo 命令临时获取 root 权限，临时以 root 的身份来操作该文件，这样就可以来查看和修改文件了，因此下面的命令是有效的：

1
2

sudo vi names.txt
sudo cat names.txt

但这样还是需要使用 sudo 才能修改，很不方便。 这时如果我们把文件的所有者改成 cqc，情况那就不一样了。 使用 ubuntu 账号，对 names.txt 更改其所有者为 cqc，改的命令如下：

1

sudo chown cqc names.txt

这时查看下文件信息：

1

-rw-r----- 1 cqc  root    8 Sep  4 20:29 names.txt

可以看到所有者信息已经变成了 cqc，这样 cqc 账号再直接查看和修改，那就可以了，不再需要 sudo 命令：

1
2

vi names.txt
cat names.txt

这样就不会有权限提示，当然加上 sudo 更是没问题。 好，接下来 lbd 呢？我们登录试试修改。 首先当前的文件状态是这样的：

1

-rw-r----- 1 cqc  root    8 Sep  4 20:31 names.txt

lbd 不是所有者了，因此前面的 rw- 权限是没什么用的，但他属于 lab 组，而该文件对于用户组的权限是 r—，也就是读取权限。 我们使用 lbd 账号来尝试看下文件的内容：

1
2

cat names.txt 
cat: names.txt: Permission denied

很遗憾，又没有权限。因为什么？因为这个文件的用户组并不是 lab 啊，而 lbd 这个用户又不属于 root 组，所以没有任何权限。 那咋办？将文件的用户组改成 lab 就好了，使用 ubuntu 账号或 cqc 账号来操作：

1

sudo chgrp lab names.txt

这样就成功将文件所属用户组改成 lab 了，接下来再使用 lbd 账号查看下文件内容：

1

cat names.txt

就成功读取了。 然而 lbd 现在是没有写入权限的，因为对于用户组来说，该文件的权限是 r—，如果要获取写入权限，我们可以使用如下命令：

1

sudo chmod g+w names.txt

或：

1

sudo chmod 660 names.txt

这样就相当于赋予了 rw- 权限，下面我们再使用 lbd 账号尝试修改这个文件：

1

vi names.txt

就没问题了。 那么对于非实验室同学 slb 呢？它没有任何权限，我们登录 slb 账号尝试修改和读取该文件：

1
2

cat names.txt
vi names.txt

均无权限。 所以说，这样我们就成功为实验室的人员赋予了权限，而非实验室的人则没有任何权限。 如果我要为 slb 赋予读取权限咋办呢？很简单，添加一下就好了：

1

sudo chmod o+r names.txt

这就是为其他用户添加了读取权限。这时 slb 就可以读取文件，但不能修改文件，也是比较安全的。 好，如果我的文件非常多呢？比如十几二十个，都放在 share 文件夹内，那不能一个个进行权限设置吧？ 这时候我们只需要针对文件夹进行操作即可，下面的命令就可以为 share 文件夹赋予 775 权限，即所有者 cqc 和所在组 lab 可对其进行查看和修改，其他的人只能看不能改：

1
2
3

sudo chmod -R 775 share/
sudo chown -R cqc share/
sudo chgrp -R lab share/

注意文件夹一般都会赋予 x 权限，不然连进入文件夹的权限都没有。这也就是文件夹一般会赋予 775、755，而文件会赋予 664、600、644、640 的原因了。 赋予 775 权限之后，share 的权限就变成了：

1

drwxrwxr-x  2 cqc  lab  4096 Sep  4 20:31 share/

这样其他用户就只能看，不能改，这样普通文件就没什么问题了。 如文件夹内包含了可执行文件，还可以单独为其他用户针对可执行文件去除 x 权限，如去除 Python 文件的可执行权限：

1

sudo chmod o-x *.py

好了，到现在为止，我们就得心应手地完成了权限控制了！ 相信如果你耐心看完的话，什么用户管理、权限管理，都不在话下！

本文介绍一下如何给 Azure 的云服务器增加一块磁盘。

页面操作

首先切换到磁盘页面，然后点击添加数据磁盘按钮： 然后选定存储容器，这里使用的是存储账户 Blob，然后点击确定按钮： 主机缓存切换为“读/写”，然后点击保存： 这样就添加好了。

挂载磁盘

接下来回到 Linux 服务器下，我们需要将磁盘进行挂载。 首先 SSH 连接到服务器，然后使用 dmesg 命令来查找磁盘：

1

dmesg | grep SCSI

输出类似如下：

1
2
3
4
5
6

[    0.728389] SCSI subsystem initialized
[    2.139341] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 244)
[    2.978928] sd 1:0:1:0: [sdb] Attached SCSI disk
[    3.341183] sd 0:0:0:0: [sda] Attached SCSI disk
[   18.397942] Loading iSCSI transport class v2.0-870.
[ 6641.364794] sd 3:0:0:0: [sdc] Attached SCSI disk

这里 sdc 就是我们新添加的一块硬盘。 然后我们使用 fdisk 对其进行分区，将其设置为分区 1 中的主磁盘，并接受其他的默认值，命令如下：

1

sudo fdisk /dev/sdc

使用 n 命令添加新分区，然后 p 选择主分区，其他的默认：

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

Welcome to fdisk (util-linux 2.27.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.


Device does not contain a recognized partition table.
Created a new DOS disklabel with disk identifier 0xc305fe54.

Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 
First sector (2048-2145386495, default 2048): 
Last sector, +sectors or +size{K,M,G,T,P} (2048-2145386495, default 2145386495): 

Created a new partition 1 of type 'Linux' and of size 1023 GiB.

然后使用 p 打印分区表并使用 w 将表写入磁盘，然后退出：

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

Command (m for help): p
Disk /dev/sdc: 1023 GiB, 1098437885952 bytes, 2145386496 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xc305fe54

Device     Boot Start        End    Sectors  Size Id Type
/dev/sdc1        2048 2145386495 2145384448 1023G 83 Linux

Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.

接下来使用 mkfs 命令将文件系统写入分区，指定文件系统的类型和设备名称：

1

sudo mkfs -t ext4 /dev/sdc1

输出类似如下：

1
2
3
4
5
6
7
8
9
10
11
12

mke2fs 1.42.13 (17-May-2015)
Creating filesystem with 268173056 4k blocks and 67043328 inodes
Filesystem UUID: d744c5d7-f4d1-4f81-9f56-59dfab956782
Superblock backups stored on blocks: 
        32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
        4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968, 
        102400000, 214990848

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done

然后使用 mkdir 创建一个目录来装载该文件系统，然后挂载：

1
2

sudo mkdir /datadrive
sudo mount /dev/sdc1 /datadrive

这样就挂载成功了。

添加引导信息

若要确保在重新引导后自动重新装载驱动器，必须将其添加到 /etc/fstab 文件。 此外，强烈建议在 /etc/fstab 中使用 UUID（全局唯一标识符）来引用驱动器而不是只使用设备名称（例如 /dev/sdc1）。 如果 OS 在启动过程中检测到磁盘错误，使用 UUID 可以避免将错误的磁盘装载到给定位置。 然后，为剩余的数据磁盘分配这些设备 ID。 若要查找新驱动器的 UUID，请使用 blkid 实用工具：

1

sudo -i blkid

输入类似如下：

1
2
3

/dev/sdb1: UUID="d5b61f40-4129-4b39-b861-c2d3b09cee69" TYPE="ext4" PARTUUID="4927b944-01"
/dev/sda1: LABEL="cloudimg-rootfs" UUID="b2e62f4f-d338-470e-9ae7-4fc0e014858c" TYPE="ext4" PARTUUID="577c3e7c-01"
/dev/sdc1: UUID="d744c5d7-f4d1-4f81-9f56-59dfab956782" TYPE="ext4" PARTUUID="c305fe54-01"

然后编辑 /etc/fstab，添加下面一行：

1

UUID=d744c5d7-f4d1-4f81-9f56-59dfab956782       /datadrive      ext4    defaults,nofail 1      2

然后保存退出即可。 这样就成功添加了一块外部磁盘。

为何要搭建 Elasticsearch 集群

凡事都要讲究个为什么。在搭建集群之前，我们首先先问一句，为什么我们需要搭建集群？它有什么优势呢？

高可用性

Elasticsearch 作为一个搜索引擎，我们对它的基本要求就是存储海量数据并且可以在非常短的时间内查询到我们想要的信息。所以第一步我们需要保证的就是 Elasticsearch 的高可用性，什么是高可用性呢？它通常是指，通过设计减少系统不能提供服务的时间。假设系统一直能够提供服务，我们说系统的可用性是 100%。如果系统在某个时刻宕掉了，比如某个网站在某个时间挂掉了，那么就可以它临时是不可用的。所以，为了保证 Elasticsearch 的高可用性，我们就应该尽量减少 Elasticsearch 的不可用时间。 那么怎样提高 Elasticsearch 的高可用性呢？这时集群的作用就体现出来了。假如 Elasticsearch 只放在一台服务器上，即单机运行，假如这台主机突然断网了或者被攻击了，那么整个 Elasticsearch 的服务就不可用了。但如果改成 Elasticsearch 集群的话，有一台主机宕机了，还有其他的主机可以支撑，这样就仍然可以保证服务是可用的。 那可能有的小伙伴就会说了，那假如一台主机宕机了，那么不就无法访问这台主机的数据了吗？那假如我要访问的数据正好存在这台主机上，那不就获取不到了吗？难道其他的主机里面也存了一份一模一样的数据？那这岂不是很浪费吗？ 为了解答这个问题，这里就引出了 Elasticsearch 的信息存储机制了。首先解答上面的问题，一台主机宕机了，这台主机里面存的数据依然是可以被访问到的，因为在其他的主机上也有备份，但备份的时候也不是整台主机备份，是分片备份的，那这里就又引出了一个概念——分片。 分片，英文叫做 Shard，顾名思义，分片就是对数据切分成了多个部分。我们知道 Elasticsearch 中一个索引（Index）相当于是一个数据库，如存某网站的用户信息，我们就建一个名为 user 的索引。但索引存储的时候并不是整个存一起的，它是被分片存储的，Elasticsearch 默认会把一个索引分成五个分片，当然这个数字是可以自定义的。分片是数据的容器，数据保存在分片内，分片又被分配到集群内的各个节点里。当你的集群规模扩大或者缩小时， Elasticsearch 会自动的在各节点中迁移分片，使得数据仍然均匀分布在集群里，所以相当于一份数据被分成了多份并保存在不同的主机上。 那这还是没解决问题啊，如果一台主机挂掉了，那么这个分片里面的数据不就无法访问了？别的主机都是存储的其他的分片。其实是可以访问的，因为其他主机存储了这个分片的备份，叫做副本，这里就引出了另外一个概念——副本。 副本，英文叫做 Replica，同样顾名思义，副本就是对原分片的复制，和原分片的内容是一样的，Elasticsearch 默认会生成一份副本，所以相当于是五个原分片和五个分片副本，相当于一份数据存了两份，并分了十个分片，当然副本的数量也是可以自定义的。这时我们只需要将某个分片的副本存在另外一台主机上，这样当某台主机宕机了，我们依然还可以从另外一台主机的副本中找到对应的数据。所以从外部来看，数据结果是没有任何区别的。 一般来说，Elasticsearch 会尽量把一个索引的不同分片存储在不同的主机上，分片的副本也尽可能存在不同的主机上，这样可以提高容错率，从而提高高可用性。 但这时假如你只有一台主机，那不就没办法了吗？分片和副本其实是没意义的，一台主机挂掉了，就全挂掉了。

健康状态

针对一个索引，Elasticsearch 中其实有专门的衡量索引健康状况的标志，分为三个等级：

• green，绿色。这代表所有的主分片和副本分片都已分配。你的集群是 100% 可用的。
• yellow，黄色。所有的主分片已经分片了，但至少还有一个副本是缺失的。不会有数据丢失，所以搜索结果依然是完整的。不过，你的高可用性在某种程度上被弱化。如果更多的分片消失，你就会丢数据了。所以可把 yellow 想象成一个需要及时调查的警告。
• red，红色。至少一个主分片以及它的全部副本都在缺失中。这意味着你在缺少数据：搜索只能返回部分数据，而分配到这个分片上的写入请求会返回一个异常。

如果你只有一台主机的话，其实索引的健康状况也是 yellow，因为一台主机，集群没有其他的主机可以防止副本，所以说，这就是一个不健康的状态，因此集群也是十分有必要的。

存储空间

另外，既然是群集，那么存储空间肯定也是联合起来的，假如一台主机的存储空间是固定的，那么集群它相对于单个主机也有更多的存储空间，可存储的数据量也更大。 所以综上所述，我们需要一个集群！

详细了解 Elasticsearch 集群

接下来我们再来了解下集群的结构是怎样的。 首先我们应该清楚多台主机构成了一个集群，每台主机称作一个节点（Node）。 如图就是一个三节点的集群：

在图中，每个 Node 都有三个分片，其中 P 开头的代表 Primary 分片，即主分片，R 开头的代表 Replica 分片，即副本分片。所以图中主分片 1、2，副本分片 0 储存在 1 号节点，副本分片 0、1、2 储存在 2 号节点，主分片 0 和副本分片 1、2 储存在 3 号节点，一共是 3 个主分片和 6 个副本分片。同时我们还注意到 1 号节点还有个 MASTER 的标识，这代表它是一个主节点，它相比其他的节点更加特殊，它有权限控制整个集群，比如资源的分配、节点的修改等等。 这里就引出了一个概念就是节点的类型，我们可以将节点分为这么四个类型：

• 主节点：即 Master 节点。主节点的主要职责是和集群操作相关的内容，如创建或删除索引，跟踪哪些节点是群集的一部分，并决定哪些分片分配给相关的节点。稳定的主节点对集群的健康是非常重要的。默认情况下任何一个集群中的节点都有可能被选为主节点。索引数据和搜索查询等操作会占用大量的 cpu，内存，io 资源，为了确保一个集群的稳定，分离主节点和数据节点是一个比较好的选择。虽然主节点也可以协调节点，路由搜索和从客户端新增数据到数据节点，但最好不要使用这些专用的主节点。一个重要的原则是，尽可能做尽量少的工作。
• 数据节点：即 Data 节点。数据节点主要是存储索引数据的节点，主要对文档进行增删改查操作，聚合操作等。数据节点对 CPU、内存、IO 要求较高，在优化的时候需要监控数据节点的状态，当资源不够的时候，需要在集群中添加新的节点。
• 负载均衡节点：也称作 Client 节点，也称作客户端节点。当一个节点既不配置为主节点，也不配置为数据节点时，该节点只能处理路由请求，处理搜索，分发索引操作等，从本质上来说该客户节点表现为智能负载平衡器。独立的客户端节点在一个比较大的集群中是非常有用的，他协调主节点和数据节点，客户端节点加入集群可以得到集群的状态，根据集群的状态可以直接路由请求。
• 预处理节点：也称作 Ingest 节点，在索引数据之前可以先对数据做预处理操作，所有节点其实默认都是支持 Ingest 操作的，也可以专门将某个节点配置为 Ingest 节点。

以上就是节点几种类型，一个节点其实可以对应不同的类型，如一个节点可以同时成为主节点和数据节点和预处理节点，但如果一个节点既不是主节点也不是数据节点，那么它就是负载均衡节点。具体的类型可以通过具体的配置文件来设置。

怎样搭建 Elasticsearch 集群

好，接下来我们就来动手搭建一个集群吧。 这里我一共拥有七台 Linux 主机，系统是 Ubuntu 16.04，都连接在一个内网中，IP 地址为：

1
2
3
4
5
6
7

10.0.0.4
10.0.0.5
10.0.0.6
10.0.0.7
10.0.0.8
10.0.0.9
10.0.0.10

每台主机的存储空间是 1TB，内存是 13GB。 下面我们来一步步介绍如何用这几台主机搭建一个 Elasticsearch 集群，这里使用的 Elasticsearch 版本是 6.3.2，另外我们还需要安装 Kibana 用来可视化监控和管理 Elasticsearch 的相关配置和数据，使得集群的管理更加方便。 环境配置如下所示：

名称

内容

主机台数

7

主机内存

13GB

主机系统

Ubuntu 16.04

存储空间

1TB

Elasticsearch 版本

6.3.2

Java 版本

1.8

Kibana 版本

6.3.2

安装 Java

Elasticsearch 是基于 Lucene 的，而 Lucene 又是基于 Java 的。所以第一步我们就需要在每台主机上安装 Java。 首先更新 Apt 源：

1

sudo apt-get update

然后安装 Java：

1

sudo apt-get install default-jre

安装好了之后可以检查下 Java 的版本：

1

java -version

这里的版本是 1.8，类似输出如下：

1
2
3

openjdk version "1.8.0_171"
OpenJDK Runtime Environment (build 1.8.0_171-8u171-b11-0ubuntu0.16.04.1-b11)
OpenJDK 64-Bit Server VM (build 25.171-b11, mixed mode)

如果看到上面的内容就说明安装成功了。 注意一定要每台主机都要安装。

安装 Elasticsearch

接下来我们来安装 Elasticsearch，同样是每台主机都需要安装。 首先需要添加 Apt-key：

1

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

然后添加 Elasticsearch 的 Repository 定义：

1

echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list

接下来安装 Elasticsearch 即可：

1
2

sudo apt-get update 
sudo apt-get install elasticsearch

运行完毕之后我们就完成了 Elasticsearch 的安装，注意还是要每台主机都要安装。

配置 Elasticsearch

这时我们只是每台主机都安装好了 Elasticsearch，接下来我们还需要将它们联系在一起构成一个集群。 安装完之后，Elasticsearch 的配置文件是 /etc/elasticsearch/elasticsearch.yml，接下来让我们编辑一下配置文件：

• 集群的名称

通过 cluster.name 可以配置集群的名称，集群是一个整体，因此名称都要一致，所有主机都配置成相同的名称，配置示例：

1

cluster.name: germey-es-clusters

• 节点的名称

通过 node.name 可以配置每个节点的名称，每个节点都是集群的一部分，每个节点名称都不要相同，可以按照顺序编号，配置示例：

1

node.name: es-node-1

其他的主机可以配置为 es-node-2、es-node-3 等。

• 是否有资格成为主节点

通过 node.master 可以配置该节点是否有资格成为主节点，如果配置为 true，则主机有资格成为主节点，配置为 false 则主机就不会成为主节点，可以去当数据节点或负载均衡节点。注意这里是有资格成为主节点，不是一定会成为主节点，主节点需要集群经过选举产生。这里我配置所有主机都可以成为主节点，因此都配置为 true，配置示例： node.master: true

• 是否是数据节点

通过 node.data 可以配置该节点是否为数据节点，如果配置为 true，则主机就会作为数据节点，注意主节点也可以作为数据节点，当 node.master 和 node.data 均为 false，则该主机会作为负载均衡节点。这里我配置所有主机都是数据节点，因此都配置为 true，配置示例： node.data: true

• 数据和日志路径

通过 path.data 和 path.logs 可以配置 Elasticsearch 的数据存储路径和日志存储路径，可以指定任意位置，这里我指定存储到 1T 硬盘对应的路径下，另外注意一下写入权限问题，配置示例： path.data: /datadrive/elasticsearch/data path.logs: /datadrive/elasticsearch/logs

• ​ 设置访问的地址和端口

我们需要设定 Elasticsearch 运行绑定的 Host，默认是无法公开访问的，如果设置为主机的公网 IP 或 0.0.0.0 就是可以公开访问的，这里我们可以都设置为公开访问或者部分主机公开访问，如果是公开访问就配置为：

1

network.host: 0.0.0.0

如果不想被公开访问就不用配置。 另外还可以配置访问的端口，默认是 9200： http.port: 9200

• 集群地址设置

通过 discovery.zen.ping.unicast.hosts 可以配置集群的主机地址，配置之后集群的主机之间可以自动发现，这里我配置的是内网地址，配置示例：

1

discovery.zen.ping.unicast.hosts: ["10.0.0.4", "10.0.0.5", "10.0.0.6", "10.0.0.7", "10.0.0.8", "10.0.0.9", "10.0.0.10"]

这里请改成你的主机对应的 IP 地址。

• 节点数目相关配置

为了防止集群发生“脑裂”，即一个集群分裂成多个，通常需要配置集群最少主节点数目，通常为 (可成为主节点的主机数目 / 2) + 1，例如我这边可以成为主节点的主机数目为 7，那么结果就是 4，配置示例：

1

discovery.zen.minimum_master_nodes: 4

另外还可以配置当最少几个节点回复之后，集群就正常工作，这里我设置为 4，可以酌情修改，配置示例：

1

gateway.recover_after_nodes: 4

其他的暂时先不需要配置，保存即可。注意每台主机都需要配置。

启动 Elasticsearch

配置完成之后就可以在每台主机上分别启动 Elasticsearch 服务了，命令如下：

1
2
3

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch.service
sudo systemctl start elasticsearch.service

所有主机都启动之后，我们在任意主机上就可以查看到集群状态了，命令行如下：

1

curl -XGET 'http://localhost:9200/_cluster/state?pretty'

类似的输出如下：

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

{
    "cluster_name": "germey-es-clusters",
    "compressed_size_in_bytes": 20799,
    "version": 658,
    "state_uuid": "a64wCwPnSueKRtVuKx8xRw",
    "master_node": "73BQvOC2TpSXcr-IXBcDdg",
    "blocks": {},
    "nodes": {
        "I2M80AP-T7yVP_AZPA0bpA": {
            "name": "es-node-1",
            "ephemeral_id": "KpCG4jNvTUGKNHNwKKoMrA",
            "transport_address": "10.0.0.4:9300",
            "attributes": {
                "ml.machine_memory": "7308464128",
                "ml.max_open_jobs": "20",
                "xpack.installed": "true",
                "ml.enabled": "true"
            }
        },
        "73BQvOC2TpSXcr-IXBcDdg": {
            "name": "es-node-7",
            "ephemeral_id": "Fs9v2XTASnGbqrM8g7IhAQ",
            "transport_address": "10.0.0.10:9300",
            "attributes": {
                "ml.machine_memory": "14695202816",
                "ml.max_open_jobs": "20",
                "xpack.installed": "true",
                "ml.enabled": "true"
            }
        },
....

可以看到这里输出了集群的相关信息，同时 nodes 字段里面包含了每个节点的详细信息，这样一个基本的集群就构建完成了。

安装 Kibana