早之前曾经写过过一篇文章 总结 adb 的常用命令，这次刷机也复习了一些命令，这里再补充一下刷机中必不可少的 fastboot 命令。

就像之前 adb 中说过的那样， adb 用来向开机的 Android 设备发送指令，而 fastboot 则是向开机的 Android bootloader 来发送指令，因此在刷机过程中，如果手机重启进入 bootloader 基本之后使用的 命令都离不开 fastboot。比如在安装第三方 recovery 时，要用到 fastboot flash recovery recovery.img 这样的指令。虽然不能依靠此命令来刷入 ROM，但是 fastboot 也能够做一些 adb 命令无法实现的功能。

安装

sudo apt-get install android-tools-fastboot

bootloader

关于 bootloader 部分可以参考 之前的文章

fastboot

adb 和 fastboot 两个工具都是跟随着 Android SDK 分发的，但是由于这两个工具需求过高，Google 单独提供了两个工具集的下载。

在下载之后，需要将文件路径添加到系统环境变量中，以便于在各个路径下访问。

假设加压后的路径为 ~/Android/Sdk/platform-tools/， 那需要在 ～/.bashrc 或者 ~/.zshrc 中配置。

export PATH="$PATH:/home/einverne/Android/Sdk/platform-tools"

WIndows 同理，在系统配置环境变量。

然后在终端下使用 adb devices ，就能够查看连接的设备。同样在 bootloader 下，也可以使用 fastboot devices 来查看连接设备，如果未出现已经 USB 连接的设备，查看驱动是否安装完好即可。

查看设备

fastboot devices

用 boot.img 启动手机

用当前目录下的 boot.img 启动手机，在手机 boot 分区损坏的情况下可以用这个正常进入系统

fastboot boot boot.img

同理可以使用

fastboot boot recovery.img

来启动 recovery 模式

和手机上现有的系统完全无关，只要 PC 的 boot.img 或者 recovery.img 是可以正常工作的就可以。

修改分区

刷机的人经常会遇到下面一些场景。

将当前目录下的 boot.img 刷入手机的 boot 分区：

fastboot flash boot boot.img

将当前目录下的 recovery.img 刷入系统的 recovery 分区：

fastboot flash recovery recovery.img

将当前目录下的 system.img 刷入系统的 system 分区：

fastboot flash system system.img

同理，刷入 data 分区

fastboot flash userdata userdata.img

清理分区的命令，慎用！！！

fastboot erase system
fastboot erase cache
fastboot erase config
fastboot erase data
fastboot erase logs
fastboot erase factory

最后重启手机

fastboot reboot

本文介绍 Android 反编译工具，只介绍工具名字及工具简单使用，详细开来再具体讲吧。本文主要包含工具的作用，工作的简单用法，以及反编译的基本步骤。

概述

反编译 Android APK 主要需要依靠如下几个工具:

• apktool：A tool for reverse engineering Android apk files 查看 APK 包中的 AndroidManifest.xml 等 XML 资源文件
• dex2jar：Tools to work with android .dex and java .class files 将 APK 包中的 Dalvik 字节码文件（.dex）转换为 .jar 文件
• JD-GUI：Java Decompiler is a tools to decompile and analyze Java 5 “byte code” and the later versions 查看 .jar 文件的 Java 源码

相关项目及工具地址后文贴出。

使用方法

apktool

Apktook 是一个反编译(reverse engineering) 工具，可以用来反编译Android APK。几乎可以将APK中的 resources.arsc, classes.dex 和 9.png 以及 XMLs 等等源文件反编译得到。

安装需要：

1. JRE 1.7 及以上
2. 关于 Android SDK, AAPT 以及 smali 的基本知识

地址: https://ibotpeaches.github.io/Apktool/

apktool 安装

各平台的安装指南，如果使用 Linux 可以使用如下简易步骤：

1. 右击链接 将 Linux 的脚本保存为 apktool，并移动到 /usr/local/bin/ 目录下
2. 下载最新版本 apktool.jar (https://bitbucket.org/iBotPeaches/apktool/downloads/)
3. 确保 Linux 64 位系统中安装了 ia32-libs，使用 apt search ia32 ，然后 apt install ia32-libs 安装，可跳过
4. 将下载的 apktool-x.x.x.jar 重命名为 apktool.jar
5. 将 apktool.jar 和 apktool 移动到 /usr/local/bin/ 目录中，需要 root 权限
6. 给予以上两者执行权限 chmod +x /usr/local/bin/apktool
7. 在终端执行 apktool

apktool 使用

1. 拿到 APK 安装包，比如 xxx.apk
2. 在APK同目录下，执行 apktool d xxx.apk
3. 目录下会多一个与 APK 同名的文件夹，是解压后的 APK，其中的 XML 资源文件和各种 drawable 图片资源等可以直接看, 不想看 XML 文件的话，可以不用 apktool，直接将 APK 后缀改为 .zip 后解压即可，此时得到的解压目录中的结构和 apktool 解的是一样的，但是 XML 都处在压缩状态不能看。

Apktool 其实还可以用来做另外一件事情，就是汉化，或者将语言包替换之后，重新打包，此时需要使用 apktool b xxx.apk 来重新打包 APK。

dex2jar

dex2jar 能够将 dex 转换为 jar

地址：https://github.com/pxb1988/dex2jar

1. 不使用 apktool，直接修改后缀解压 APK，将解压后 APK 中的 .dex 文件复制到 dex2jar 目录下
2. 进入该目录执行 ./d2j-dex2jar.sh xxx.dex（注意赋予该 shell 可执行权限 chmod +x d2j-dex2jar.sh）

JD GUI

JD GUI 用来反编译源文件jar包，查看源代码

地址：http://jd.benow.ca/

1. dex2jar 目录下会多一个 .jar 文件，用 GUI 工具 JD-GUI 打开看就可以了（当然，混淆过的代码中变量名都是 a, b, c, d）

总结

总的来说 apktool 可以让你轻松的拿到应用的资源文件，包括图片，xml等，而 dex2jar 和 JD GUI 可以反编译源代码，看到一些基础的代码结构。

Update

后来 Google 搞了一个 ClassyShark，看起来不错，不过还没来得及尝试

http://classyshark.com/

还有一个 不错的 smali 查看插件看起来也不错，还未尝试

https://github.com/JesusFreke/smali

另外有一个 MAC 专属的一键反编译工具，可以一试：

https://github.com/Jermic/Android-Crack-Tool

又一个查看 dex 到 jar 的反编译工具:

https://github.com/skylot/jadx

我们知道如果使用 Nginx 可以使用 Virtual HOST 来 HOST 多个域名下的网站到同一台机器，那么如果使用 Docker 架设了一个 WordPress，还想用 Docker 架设一个新的网站，那么该怎么办呢？

有一种解决办法就是使用 Nginx 转发请求，比如一个网站监听了 81 端口，一个网站监听了 82 端口，那么使用 Nginx 的代理功能，将对应的流量转发给对应的服务器处理即可。因此 nginx-proxy 这个镜像的作用就如上面所述，让我们将不同的流量转发给不同的 Docker 容器进行处理。

启动 nginx-proxy

有两种方式可以启动 nginx-proxy 容器，一种是通过 docker 命令，另一种是使用 docker-compose。不过用这两种方式之前，先创建一个 Docker network，将多个容器关联起来

docker network create nginx-proxy

然后创建容器

docker run -d -p 80:80 --name nginx-proxy --net nginx-proxy -v /var/run/docker.sock:/tmp/docker.sock jwilder/nginx-proxy

或者创建 docker-compose.yml ：

version: "3"
services:
  nginx-proxy:
    image: jwilder/nginx-proxy
    container_name: nginx-proxy
    ports:
      - "80:80"
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro

networks:
  default:
    external:
      name: nginx-proxy

然后在同目录下 docker-compose up -d

nginx-proxy 对外暴露 80 端口，并且监听 80 端口，允许 80 端口的流量流入。而 /var/run/docker.sock:/tmp/docker.sock 这一行则表示着允许该容器访问宿主机器的 Docker socket，这也就意味着有新容器加入，或者新容器关闭时都会通知到 nginx-proxy。

这样每一次添加容器，nginx-proxy 就会通过 socket 来接收到事件，自动创建对应的配置文件，然后重启 nginx 来生效。nginx-proxy 会寻找带有 VIRTUAL_HOST 环境变量的容器，然后依照配置进行。

另外 --net nginx-proxy 和 docker compose 中 networks 块的配置，让所有的容器通过 Docker network 进行通讯。

增加容器

比如增加一个 WordPress 容器

docker run -d --name blog --expose 80 --net nginx-proxy -e VIRTUAL_HOST=blog.DOMAIN.TLD wordpress

• --expose 80 会允许流量从 80 端口流入
• --net nginx-proxy 保证 Docker 使用同一个网络
• -e VIRTUAL_HOST=blog.DOMAIN.TLD 开启 nginx-proxy 创建对应的配置文件将流量转发给 WordPress 容器

如果使用 Docker compose

version: "3"

services:
   db_node_domain:
     image: mysql:5.7
     volumes:
       - db_data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: PASSWORD
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: PASSWORD
     container_name: wordpress_db

   wordpress:
     depends_on:
       - db_node_domain
     image: wordpress:latest
     expose:
       - 80
     restart: always
     environment:
       VIRTUAL_HOST: blog.DOMAIN.TLD
       WORDPRESS_DB_HOST: db_node_domain:3306
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: PASSWORD
     container_name: wordpress
volumes:
    db_data:

networks:
  default:
    external:
      name: nginx-proxy

不过这里需要注意的是会创建一个数据库容器，一个 WordPress app 容器。

扩展

如果想要支持 SSL，那么 nginx-proxy 有一个对应的项目 letsencrypt-nginx-proxy-companion，他可以自动创建和续签 Let’s Encrypt 的证书。

reference

• https://github.com/jwilder/nginx-proxy
• https://github.com/einverne/dockerfile/tree/master/nginx-proxy
• https://gtk.pw/Wy5BG

Busybox 将很多 UNIX 下的工具集打包到一个可执行文件中，特别适合小容量的嵌入式设备，Android 等等。最近也是因为在 Android 用到才接触到。

实际的命令列表按编译时的设置决定，在有 Busybox 的系统上执行 busybox --list 即可看到一个完整的列表。

127|:/ $ busybox
BusyBox v1.30.1-osm0sis (2019-02-28 18:48:08 AST) multi-call binary.BusyBox is copyrighted by many authors between 1998-2015.
Licensed under GPLv2. See source distribution for detailed
copyright notices.

Usage: busybox [function [arguments]...]
   or: busybox --list[-full]
   or: busybox --show SCRIPT
   or: busybox --install [-s] [DIR]
   or: function [arguments]...

        BusyBox is a multi-call binary that combines many common Unix
        utilities into a single executable.  Most people will create a
        link to busybox for each function they wish to use and BusyBox
        will act like whatever it was invoked as.

Currently defined functions:
        [, [[, acpid, adjtimex, ar, arch, arp, arping, ash, awk,
        base64, basename, bbconfig, beep, blkdiscard, blkid,
        blockdev, brctl, bunzip2, bzcat, bzip2, cal, cat, chat,
        chattr, chgrp, chmod, chown, chroot, chrt, chvt, cksum,
        clear, cmp, comm, conspy, cp, cpio, crond, crontab,
        cttyhack, cut, date, dc, dd, deallocvt, depmod, devmem, df,
        dhcprelay, diff, dirname, dmesg, dnsd, dnsdomainname,
        dos2unix, du, dumpkmap, dumpleases, echo, ed, egrep, eject,
        env, ether-wake, expand, expr, factor, fakeidentd, false,
        fatattr, fbset, fbsplash, fdflush, fdformat, fdisk,
        fgconsole, fgrep, find, findfs, flock, fold, free,
        freeramdisk, fsck, fsck.minix, fsfreeze, fstrim, fsync,
        ftpd, ftpget, ftpput, fuser, getopt, grep, groups, gunzip,
        gzip, hd, hdparm, head, hexdump, hexedit, hostname, httpd,
        hush, hwclock, id, ifconfig, ifdown, ifenslave, ifplugd,
        ifup, inetd, inotifyd, insmod, install, ionice, iostat, ip,
        ipaddr, ipcalc, ipcrm, ipcs, iplink, ipneigh, iproute,
        iprule, iptunnel, kbd_mode, kill, killall, killall5, klogd,
        less, link, ln, loadfont, loadkmap, logread, losetup, ls,
        lsattr, lsmod, lsof, lspci, lsscsi, lsusb, lzcat, lzma,
        lzop, lzopcat, makedevs, makemime, man, md5sum, mesg,
        microcom, mkdir, mkdosfs, mke2fs, mkfifo, mkfs.ext2,
        mkfs.minix, mkfs.reiser, mkfs.vfat, mknod, mkswap, mktemp,
        modinfo, modprobe, more, mount, mountpoint, mpstat, mv,
        nameif, nanddump, nandwrite, nbd-client, nc, netstat, nice,
        nl, nmeter, nohup, nologin, nslookup, nuke, od, openvt,
        partprobe, paste, patch, pgrep, pidof, ping, ping6,
        pipe_progress, pivot_root, pkill, pmap, popmaildir,
        poweroff, powertop, printenv, printf, ps, pscan, pstree,
        pwd, pwdx, raidautorun, rdate, rdev, readlink, readprofile,
        realpath, reboot, reformime, renice, reset, resize, resume,
        rev, rfkill, rm, rmdir, rmmod, route, rtcwake, run-init,
        run-parts, rx, script, scriptreplay, sed, sendmail, seq,
        setconsole, setfattr, setfont, setkeycodes, setlogcons,
        setpriv, setserial, setsid, setuidgid, sh, sha1sum,
        sha256sum, sha3sum, sha512sum, showkey, shred, shuf,
        slattach, sleep, smemcap, sort, split, ssl_client,
        start-stop-daemon, stat, strings, stty, sum, svc, svok,
        swapoff, swapon, switch_root, sync, sysctl, syslogd, tac,
        tail, tar, tc, tcpsvd, tee, telnet, telnetd, test, tftp,
        tftpd, time, timeout, top, touch, tr, traceroute,
        traceroute6, true, truncate, tty, ttysize, tunctl, tune2fs,
        ubiattach, ubidetach, ubimkvol, ubirename, ubirmvol,
        ubirsvol, ubiupdatevol, udhcpc, udhcpc6, udhcpd, udpsvd,
        uevent, umount, uname, uncompress, unexpand, uniq,
        unix2dos, unlink, unlzma, unlzop, unxz, unzip, uptime,
        usleep, uudecode, uuencode, vconfig, vi, volname, watch,
        watchdog, wc, wget, which, whoami, whois, xargs, xxd, xz,
        xzcat, yes, zcat, zcip
:/ $

HBase Shell 是 HBase 提供的一个简单方便的命令行工具，用它可以直接操作 HBase，对 HBase 进行各种设置。 HBase Shell 提供的命令可以对对 HBase 数据进行增删改查。在上一篇 HBase 介绍 中对 HBase 做了简答的介绍，也初识了一些命令行。

根据官方的解释 Apache HBase Shell 是 (J)Ruby 下的 IRB(Interactive Ruby Shell)，任何在 IRB 下的命令，在 HBase Shell 下都可以使用。¹

可以在启动 HBase 之后，通过 ./bin/hbase shell 来进入 HBase Shell。

常用命令

基础命令

• status

  查询服务器状态

• version

  查询 HBase 版本

• whoami

  查看连接用户

基本 SHELL 命令

查询所有表名

列举数据库中所有表

list

DDL 命令

创建表

create 命令

create 'table_name', 'cf1', 'cf2'

其中的 cf1 和 cf2 为列族名 1，列族名 2，列族需要在见表时确定，列则不需要， Column Family 是 Schema 的一部分，设计时就需要考虑。

删除表

在删除表之前需要使用 disable 命令，让表失效。在修改表结构时，也需要先执行此命令

disable "table_name'

删除表使用 drop 命令

drop 'table_name'

测试表是否存在

exists 'table_name'

会显示表是否存在：

hbase(main):002:0> exists 'test'
Table test does exist
0 row(s) in 0.2650 seconds

显示表结构

describe 命令查看表结构，显示 HBase 表 schema，以及 column family 设计

describe 'table_name'

使表有效

enable 命令，和 disable 命令对应

enable 'table_name'

修改表结构

alter 修改表的结构，新增列族，删除列族。在修改之前要先 disable ，修改完成后再 enable

新增列族

alter 'table_name', '列族'

删除列族

alter 'table_name', {name=>‘列族’, METHOD=>'delete'}

举例：

hbase(main):049:0> alter 'test','cf2'
Updating all regions with the new schema...
1/1 regions updated.
Done.
0 row(s) in 1.7520 seconds
hbase(main):050:0> describe 'test'
DESCRIPTION                                                                                                                               ENABLED
 'test', {NAME => 'cf', DATA_BLOCK_ENCODING => 'NONE', BLOOMFILTER => 'NONE', REPLICATION_SCOPE => '0', VERSIONS => '3', COMPRESSION => ' false
 NONE', MIN_VERSIONS => '0', TTL => '2147483647', KEEP_DELETED_CELLS => 'false', BLOCKSIZE => '65536', IN_MEMORY => 'false', ENCODE_ON_DI
 SK => 'true', BLOCKCACHE => 'true'}, {NAME => 'cf2', DATA_BLOCK_ENCODING => 'NONE', BLOOMFILTER => 'NONE', REPLICATION_SCOPE => '0', COM
 PRESSION => 'NONE', VERSIONS => '3', TTL => '2147483647', MIN_VERSIONS => '0', KEEP_DELETED_CELLS => 'false', BLOCKSIZE => '65536', ENCO
 DE_ON_DISK => 'true', IN_MEMORY => 'false', BLOCKCACHE => 'true'}
1 row(s) in 0.1680 seconds
hbase(main):052:0> alter 'test', {NAME => 'cf2', METHOD => 'delete'}
Updating all regions with the new schema...
1/1 regions updated.
Done.
0 row(s) in 1.5880 seconds
hbase(main):053:0> describe 'test'
DESCRIPTION                                                                                                                               ENABLED
 'test', {NAME => 'cf', DATA_BLOCK_ENCODING => 'NONE', BLOOMFILTER => 'NONE', REPLICATION_SCOPE => '0', VERSIONS => '3', COMPRESSION => ' false
 NONE', MIN_VERSIONS => '0', TTL => '2147483647', KEEP_DELETED_CELLS => 'false', BLOCKSIZE => '65536', IN_MEMORY => 'false', ENCODE_ON_DI
 SK => 'true', BLOCKCACHE => 'true'}
1 row(s) in 0.2010 seconds

通常情况下列族不能被重命名，如果需要修改列族名字，通常用命令创建一个期望的列族名字，然后将数据复制过去，然后再删除旧列族。

DML 命令

增加记录

put 命令

插入数据，对于同一个 rowkey，如果执行两次 put，则认为是更新操作

put 'table_name', 'rowkey', '列族名 1: 列名 1', 'value'

put 't1', 'r1', 'c1', 'value', ts1 一般情况下 ts1（时间戳） 可以省略， Column 可以动态扩展，每行可以有不同的 Column。

增加值

增加指定表、行的值

incr

查询表行数

计算表的行数，count 一般比较耗时，使用

count 'table_name'

查询所有 rowkey

count 'table_name', { INTERVAL => 1 }

查询记录

get 命令获取数据，HBase 的 shell 操作，大概顺序就是命令后接表名，rowkey，列名然后在后面用花括号加上其他过滤条件。

获取指定 rowkey 的指定列族指定列的数据，每个 Column 可以有任意数量的 Values，按照 Timestamp 倒序自动排序，可以使用 scan 'table_name', {VERSIONS => 10} 来验证，详细请查看 scan 命令

get 'table_name', 'rowkey', '列族名：列名'

获取指定 rowkey 的指定列族所有的数据

get 'table_name', 'rowkey', '列族名'

获取指定 rowkey 的所有数据

get 'table_name', 'rowkey'

获取指定时间戳的数据

get 'table_name', 'rowkey', {COLUMN=>'列族名：列', TIMESTAMP=>1373737746997}

获取多个版本值，查询默认返回最新的值

get 'table_name', 'rowkey', {COLUMN => '列族名：列名', VERSIONS => 2}

HBase 按照 rowkey 字典序 (1, 100, 102, 20) 自动排序，每行包含任意数量 Column，每列按照 列名 Column Key 排序。如果有列族 cf，其中有列 cf:a, cf:b, cf:c， 则按照字典序排序。

每个数据由 TabelName+RowKey+Column+Timestamp=>Value 唯一确定。

删除记录

delete 命令删除表中数据，delete 命令只能用来删除某一列。

删除指定 rowkey 的指定列族的列名数据

delete 'table_name', 'rowkey', '列族名：列名'

删除指定 rowkey 指定列族的数据

delete 'table_name', 'rowkey', '列族名‘

使用 deleteall 命令来删除 rowkey 所有 column 的 Value，删除整行数据

deleteall 'table_name', ’rowkey'

全表扫描

scan

全表扫描

hbase(main):043:0> scan 'test', {VERSIONS => 12}
ROW           				COLUMN+CELL
 rowkey1                    column=cf:a, timestamp=1487295285291, value=value 3
 rowkey1                    column=cf:a, timestamp=1487294839168, value=value 2
 rowkey1                    column=cf:a, timestamp=1487294704187, value=value 1

删除全表数据 truncate

删除全表数据，这个命令也是 disable，drop，create 命令组合而成。

truncate 'table_name'

hbase shell 脚本

shell 命令，把所有的 hbase shell 命令写到一个文件内，类似与 Linux shell 脚本顺序执行所有命令，可以使用如下方法执行。

hbase shell test.hbaseshell

reference

下面是比较完整的一个列表：

• https://learnhbase.wordpress.com/2013/03/02/hbase-shell-commands/

官方 reference

• http://hbase.apache.org/book.html

Hbase – Hadoop Database，是一个分布式的、面向列的开源数据库，该技术来源于 Fay Chang 所撰写的 Google 论文《Bigtable：一个结构化数据的分布式存储系统》。HBase 是 Google Bigtable 的开源实现，就像 Bigtable 利用了 Google 文件系统（File System）所提供的分布式数据存储一样，HBase 在 Hadoop 之上提供了类似于 Bigtable 的能力，利用 Hadoop HDFS 作为文件系统，利用 Hadoop MapReduce 来处理 HBase 中海量数据，利用 Zookeeper 作为协同服务，HBase 是 Apache 的 Hadoop 项目的子项目，

HBase 不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。另一个不同的是 HBase 基于列的而不是基于行的模式。

HBase 是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用 HBase 技术可在廉价 PC Server 上搭建起大规模结构化存储集群。HBase 不是关系型数据库，不支持 SQL。

Apache HBase™ is the Hadoop database, a distributed, scalable, big data store.

Use Apache HBase™ when you need random, realtime read/write access to your Big Data. This project’s goal is the hosting of very large tables – billions of rows X millions of columns – atop clusters of commodity hardware. Apache HBase is an open-source, distributed, versioned, non-relational database modeled after Google’s Bigtable: A Distributed Storage System for Structured Data by Chang et al. Just as Bigtable leverages the distributed data storage provided by the Google File System, Apache HBase provides Bigtable-like capabilities on top of Hadoop and HDFS.

HBase 结构

3 维 map，三个维度分别是

• rowkey 主键
• column 由 family:qualifier 两部分组成， family 列族，和 qualifier 来确定唯一的列
• timestamp 数据写入时间戳

HBase 的 map 是按照 key 来排序的，其将 key 转换为 byte[], 然后顺序进行存储。

• 表名为字符串
• Rowkey 和 ColumnName 是二进制 byte[]
• Timestamp 是 64 位整数 Java 中 long 类型
• value 是一个字节数组 byte[]

行主键 rowkey

行以 rowkey 作为唯一标识，rowkey 是一段字节数组，任何东西都能保存进去，字符串，数字等等。行按照字典序由低到高存储在表中。rowkey 可以是任意字符串，最大长度 64KB。

HBase 不支持条件查询和 Order by 查询，读取记录只能按照 rowkey 及其 range 或全表扫描，因此 rowkey 需要根据业务来设计以利用其字典序特性排序提高性能。

行的一次读写是原子操作，这个设计使得 HBase 的并发更新操作更加易懂。

列族和列 column family

列族是列的集合，要准确表示一个列，列族：列名 方式。列族（Column family）需要 在创建表时指定 ，列（Column）则不需要，可以随时在使用时创建。列族的成员在文件系统中都存储在一起，列族中所有列存储方式都一致。HBase 的每一个列都属于一个列族，以列族名为前缀，例如 A:a 和 A:b 都属于 A 列族。

时间戳 timestamp

HBase 通过 row 和 column 确定一份数据（Cell），不同版本值按照时间倒序排序，查询时默认返回最新数据。存储的值根据 tableName + RowKey + ColumnKey + Timestamp => value 唯一确定。Cell 中数据没有类型，字节码存储。

每个保存的 Cell 数据都会保存多版本，版本通过时间戳来索引，时间戳由 HBase 在数据写入时自动赋值，时间戳为系统时间毫秒。如果客户端想要显示赋值也可以，每个 Cell 中，不同时间版本数据按照时间倒序排列，最新的数据排在最前。

为了避免数据存在过多版本造成的的管理 （包括存贮和索引）负担，HBase 提供了两种数据版本回收方式。一是保存数据的最后 n 个版本，二是保存最近一段时间内的版本（比如最近七天）。用户可以针对每个列族进行单独设置。

基本使用

包括安装和基本使用

安装

从 Apache Download Mirrors 下载，从 stable 目录下下载 .tar.gz 的文件，比如 hbase-0.94.27.tar.gz

$ tar xfz hbase-0.94.27.tar.gz
$ cd hbase-0.94.27

安装依赖基础

• Linux
• JDK，需要 1.6 及以上

确保 /etc/hosts 目录下

127.0.0.1 localhost
127.0.0.1 ubuntu.ubuntu-domain ubuntu

不要有 127.0.1.1 类似的出现，用 # 注释掉，如果有 ipv6 的地址也最好注释掉或者删掉。

编辑 vim conf/hbase-site.xml

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
  <property>
    <name>hbase.rootdir</name>
    <value>file:///DIRECTORY/hbasedata</value>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/DIRECTORY/zookeeper</value>
  </property>
</configuration>

配置其中的 hbase.rootdir 指向本地的目录，目录保存 HBase 的文件，HBase 会自动创建。默认数据存储目录为 /tmp/hbase-${user.name}

编辑 conf/hbase-env.sh 文件，配置如下两项，找到本地 Java 安装目录，可以使用 whereis java 来获取，将 JDK 的根目录配置如下：

export JAVA_HOME="/usr/lib/jdk"
export HBASE_MANAGES_ZK=true

然后使用如下命令启动 HBase：

$ ./bin/start-hbase.sh

starting Master, logging to logs/hbase-user-master-example.org.out

单机模式启动，停止的脚本也在同目录下。单机模式表示 HBase 所有服务都运行在一个 JVM 中，包括 HBase 和 Zookeeper。HBase 还有另外两种启动运行方式，伪分布式和分布式模式。

连接 HBase

使用自带的客户端连接

$ ./bin/hbase shell
HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version: 0.90.0, r1001068, Fri Sep 24 13:55:42 PDT 2010
hbase(main):001:0>

初步熟悉

创建表，插入数据

hbase(main):003:0> create 'test', 'cf'
0 row(s) in 1.2200 seconds
hbase(main):003:0> list 'test'
1 row(s) in 0.0550 seconds
hbase(main):004:0> put 'test', 'row1', 'cf:a', 'value1'
0 row(s) in 0.0560 seconds
hbase(main):005:0> put 'test', 'row2', 'cf:b', 'value2'
0 row(s) in 0.0370 seconds
hbase(main):006:0> put 'test', 'row3', 'cf:c', 'value3'
0 row(s) in 0.0450 seconds

cf 为 column family 列族，列族要求在创建表时指定，列族的成员在文件系统上存储在一起，HBase 的优化存储针对列族级别。

可以使用 list 命令来查询表名

然后可以使用 scan ‘test’ 来查询

hbase(main):006:0> scan 'test'
ROW    COLUMN+CELL
 row1    column=cf:a, timestamp=1480648404221, value=value1
 row2    column=cf:b, timestamp=1480648416039, value=value2
 row3   column=cf:c, timestamp=1480648427572, value=value3
3 row(s) in 0.0450 seconds

也可以使用 get 命令来获取记录

hbase(main):008:0> get 'test', 'row1'
COLUMN      CELL
cf:a        timestamp=1288380727188, value=value1
1 row(s) in 0.0400 seconds

删除记录

delete 方法只能删除 column

hbase(main):020:0> delete 'test', 'row2', 'cf:b'
0 row(s) in 0.0080 seconds

使用 deleteall 来删除 rowkey 的所有 column

hbase(main):001:0> deleteall 'test', 'row1'
0 row(s) in 0.3090 seconds

使用 disable 和 drop 来删除表

hbase(main):012:0> disable 'test'
0 row(s) in 1.0930 seconds
hbase(main):013:0> drop 'test'
0 row(s) in 0.0770 seconds

不清楚命令使用格式，可以使用 help "list" 来查看命令的具体使用帮助。

退出使用 exit<Enter>

最后退出可以使用 ./bin/stop-hbase.sh 来停止 hbase。

其他问题

Mac 下尝试

Mac 下安装 HBase 可以参考这篇

• http://chase-seibert.github.io/blog/2013/02/01/getting-starting-with-hbase-and-pig.html

其他问题

Hbase error zookeeper exists failed after 3 retries

16/12/02 10:45:28 INFO zookeeper.ClientCnxn: Opening socket connection to server localhost/127.0.0.1:2181. Will not attempt to authenticate using SASL (unknown error)
16/12/02 10:45:28 WARN zookeeper.ClientCnxn: Session 0x0 for server null, unexpected error, closing socket connection and attempting

配置

更多的配置可以参考

http://hbase.apache.org/0.94/book/configuration.html

• standalone mode
• Pseudo-Distributed mode
• Distributed mode

reference

• http://hbase.apache.org/
• http://hbase.apache.org/book.html#quickstart
• http://hbase.apache.org/0.94/book/quickstart.html#d1984e105
• https://www.cloudera.com/documentation/enterprise/5-8-x/topics/cdh_ig_hbase_installation.html
• https://www.tutorialspoint.com/hbase/hbase_installation.htm
• https://www.tutorialspoint.com/hbase/hbase_overview.htm
• http://blog.csdn.net/u014419512/article/details/27966957
• http://www.cnblogs.com/vichao/p/3187369.html

这是清理记事本的文章，解决一个问题之后，将之前整理的内容，整理发布。清空 WizNote 计划。

问题

手上有一些视频链接的 URL，如何快速的得到这些视频的时长信息？

答案

经过一番调研，发现使用 ffprobe (和 ffmpeg 套件一起) 可以完美解决这个事情。将命令 -i 参数后面的地址改成线上URL 地址即可。

ffprobe -i https://cldup.com/po79gkocrO.mp4 -show_entries format=duration -v quiet -of csv="p=0"

也可以将此代码保存为 get_video_duration.sh 来使用 ./get_video_duration.sh URL 这样的方式来跑。

ffprobe -i $1 -show_entries format=duration -v quiet -of csv="p=0"

具体 bash script, 文件中每一行中，前面为 视频ID，空格，再是视频连接，使用下面脚本，将视频时长保存到 duration.txt 文件中。

set -o nounset                              # Treat unset variables as an error
while IFS='' read -r line || [[ -n "$line" ]]; do
    lineArray=($line)
    echo ${lineArray[0]}
    duration=$(ffprobe -i ${lineArray[1]} -show_entries format=duration -v quiet -of csv="p=0")
    echo $duration
    echo "${lineArray[0]} ${duration}" >> duration.txt
done < "$1"

扩展

如果视频文件在本地的话，可能会方便很多， ffmpeg, ffprobe 都能够胜任。

ffmpeg -i input.mp4 2>&1 | grep "Duration"| cut -d ' ' -f 4 | sed s/,//
# 或者
ffprobe -show_format input.mp4 | sed -n '/duration/s/.*=//p'

reference

• https://superuser.com/questions/361329/how-to-get-length-of-video-file-from-console

Perf 全称Performance Event，是随着 Linux 2.6+ 一同发布的性能分析工具。通过它，应用程序可以利用 PMU，tracepoint 和内核中的特殊计数器来进行性能统计。它不但可以分析指定应用程序的性能问题 (per thread)，也可以用来分析内核的性能问题，当然也可以同时分析应用代码和内核，从而全面理解应用程序中的性能瓶颈。

安装

perf 工具在 linux-tools 下面，安装如下三个包即可

apt-get install linux-tools-common linux-tools-generic linux-tools-`uname -r`

Perf 能触发的事件分为三类：

• hardware : 由 PMU 产生的事件，比如 cache-misses、cpu-cycles、instructions、branch-misses …等等，通常是当需要了解程序对硬件特性使用情况时使用
• software : 是核心程序产生的事件，比如 context-switches、page-faults、cpu-clock、cpu-migrations …等等
• tracepoint : 是核心中的静态 tracepoint 所触发的事件，这些 tracepoint 用來判断在程序执行时期核心的行为

使用

当通过非 root 用户执行 perf 时会遇到权限不足的错误，需要 sudo -i 切换到 root 用户来执行

打印出 perf 可触发的 event

perf list

实时显示当前系统的性能统计信息

perf top

通过概括精简的方式提供被调试程序运行的整体情况和汇总数据

perf stat ./test

perf 命令过于复杂，他有很多子命令集，更多的信息可以参考下面的链接。

reference

• https://perf.wiki.kernel.org/index.php/Tutorial
• http://wiki.csie.ncku.edu.tw/embedded/perf-tutorial

Spark 是一个依托于 Hadoop 生态的分布式内存计算框架，在吸收了 Hadoop MapReduce 优点的基础上提出以 RDD 数据表示模型，将中间数据放到内存，用于迭代运算，适用于实时计算，交互式计算场景。

什么是 Spark

简单的讲是一个通用计算引擎。

• A fast and general engine for large-scale data processing
• An open source implementation of Resilient Distributed Datasets (RDD)
• Support cyclic data flow and in-memory computing

快速入门

• 官方快速入门文档 了解 Spark 基本使用，下载包，本地执行，了解基本的命令
• RDD 编程文档 了解 RDD 编程
• 参考官方例子 实现完整 application
• 学习 Spark on Cluster
• Spark SQL 官方文档

性能对比

内存中比 Hadoop MapReduce 快 100 倍，磁盘中快 10 倍。

几个名词

• MapReduce 分布式数据处理模式和执行环境，运行于大型商用机集群
• HDFS 分布式文件系统
• HBase 分布式，列存储数据库，HBase 使用 HDFS 作为底层存储，同时支持 MapReduce 批量计算和点查询
• Zookeeper 分布式、高可用协调服务，提供分布式锁之类的基本服务用于构建分布式应用
• Hive 分布式数据仓库，Hive 管理 HDFS 中存储的数据，并提供基于 SQL 的查询语言（运行时翻译为 MapReduce 作业）用以查询数据

基本组件

Spark 是一个用来实现快速而通用的集群计算的平台。

• Spark core 主要功能 RDD 相关 API
• Spark SQL Spark 用来操作结构化数据的程序包
• Spark Streaming 是 Spark 提供的对实时数据进行流式计算的组件
• MLlib Spark 中用来进行机器学习和数学建模的软件包
• GraphX Spark 中进行图计算的函数库
• Cluster Managers 管理集群节点的平台，包括 YARN，Mesos 和 Standalone Scheduler

RDD 弹性分布式数据集

RDD 是 Spark 的核心概念，具有容错机制可以被并行操作的元素集合。RDD 可以通过并行化（parallelizing) 一个存在于 driver program 中的集合，或者引用外部存储系统上的数据集，比如共享文件系统，HDFS，HBase 或者任何提供了 Hadoop InputFormat 的数据源。

RDDs can be roughly viewed as partitioned, locality aware distributed vectors

基本使用

通过[官方快速入门文档][1]，这个文档主要通过本地 shell 运行一些例子，通过例子可以初步的学习怎么使用 Spark，用 Spark 的思维方式思考。

看过基本的 Spark 之后可以进一步了解 [RDD 官方指南][2]，

本机运行

Spark 本身是用 Scala 写的，运行在 Java 虚拟机 (JVM) 上。要在你的电脑或集群上运行 Spark, 你要做的准备工作只是安装 Java 6 或者更新的版本。如果你希望使用 Python 接口，你还需要一个 Python 解释器 (2.6 以上版本）。

每一个 Spark 应用都由一个驱动器（driver program）来发起集群上的各种并行操作。driver program 包含应用 main 函数，定义集群上的分布式数据集。driver program 通过 SparkContext 对象访问 Spark，这个对象代表对计算集群的一个连接。

shell 中已经默认创建了一个 SparkContext 对象 sc，SparkContext 可以用来创建 RDD。driver program 通常要管理多个执行器 （executor）。

实例

Scala 版本

val sparkConf = new SparkConf().setAppName("wordcount")
val sc = new SparkContext(sparkConf)

val lines = sc.textFile("hdfs://...")
val words = lines.flatMap(_.split(" "))
val wordsCount = words.map(x=>(x,1))
val counts = wordsCount.reduceByKey(_ + _)
val result = counts.collect()

Fluent Style:

val result = sc.textFile("hdfs://...")
               .flatMap(_.split(" "))
               .map(x=>(x,1))
               .reduceByKey(_ + _)
               .collect()

RDD

Spark 中的 RDD 是一个不可变的分布式对象集合，每个 RDD 都被分为多个分区，这些分区运行在集群中的不同节点上。

RDD 支持两种操作：转化（transforming）和动作（action）。转化操作会由一个 RDD 生成一个新 RDD，比如 map(), filter() 等：

linesWithJava = lines.filter(lambda line: "Java" in line)

动作操作（action）会对 RDD 计算结果，并将结果返回到 driver program 中，或者把结果存储到外部系统（HDFS 等）中，比如 first(), count() 等：

linesWithJava.first()

创建 RDD

Spark 提供如下方式创建 RDD：

• 读取外部数据集
• driver program 中对集合并行化

最简单的方式就是将集合传给 SparkContext 的 parallilize() 方法，这种方法需要将整个数据集存放到一台机器中，所以只适合学习使用。或者使用 textFile() 来从外部存储中读取。

RDD 操作

filter() 操作不会改变已有 inputRDD 数据，会返回一个全新的 RDD。

RDD transforming 操作都是惰性求值，被调用 action 操作之前 Spark 不会开始计算。不应当将 RDD 看做存放特定数据的数据集，最好把 RDD 当作通过转化操作构建出来的，记录如何计算数据的指令列表。把数据读取到 RDD 同样也是惰性的。当调用 sc.textFile() 时，数据并没有真正的被读取。

针对集合中每个元素的操作

最常用的就是 filter 和 map。filter 接受一个函数，将 RDD 中满足该函数的值放入新的 RDD，map 接受一个函数，函数作用于每一个元素，函数返回值作为结果。

如果希望对每一个输入的元素输出多个元素，该功能操作叫做 flatMap()，提供给 flatMap() 的函数分别应用到输入的每一个元素，返回的是一个返回值序列的迭代器。输出的 RDD 不是由迭代器组成，而是一个包含各个迭代器可访问的所有元素的 RDD。 flatMap 最简单的用途，将输入的字符串切分为单词。

Scala

val lines = sc.parallelize(List("hello world", "hi"))
val words = lines.flatMap(line => line.split(" "))
words.first() // 返回"hello"

flatMap 可以看作将返回的迭代器“压扁”，得到一个由各个列表中元素组成的 RDD，而不是一个由列表组成的 RDD。

伪集合操作

RDD 本身不是严格意义上的集合，但也支持许多数学意义的集合操作，比如合并和相交。需要注意的是 RDD 具有相同的数据类型。

• rdd.distinct() 转化为唯一元素的 RDD
• rdd.union(rdd2) 并集
• rdd.intersection(rdd2) 交集
• rdd.subtract(rdd2) rdd-rdd2
• rdd.cartesian(rdd2) 笛卡尔积

action 操作

常见的 reduce，接收一个函数，函数操作两个元素并返回一个同样类型的元素。

fold() 和 reduce() 类似，接收一个与 reduce() 相同签名的函数，加上一个初始值来作为每一个分区第一次调用的结果。

aggregate() 函数不要求返回值类型必须和输入的 RDD 类型相同。比如用 aggregate 来计算 RDD 的平均值

Scala：

val result = input.aggregate((0, 0))(
    (acc, value) => (acc._1 + value, acc._2 + 1),
    (acc1, acc2) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
)
val avg = result._1 / result._2.toDouble

collect() 可以将数据返回到 driver program 中，collect() 需要将数据复制到 driver program 所以要求所有数据都必须能一同放到单台机器内存中。

take(n) 返回 RDD 中 n 个元素，并且尝试只访问尽量少的分区，会得到一个不均衡的集合。

如果数据定义了顺序，可以使用 top() 从 RDD 中获取前几个元素，top 会使用默认的顺序，也可以提供比较函数。

takeSample(withReplacement, num, seed) 函数可以从数据中获取采样，并指定是否替换。

foreach() 操作对 RDD 中每个元素进行操作，而不需要把 RDD 发回本地。

Spark SQL

Spark SQL 用来操作结构化和半结构化的数据，Spark SQL 提供：

• 从结构化数据源（JSON，Hive，Parquet) 中读取数据
• 不仅支持 Spark 内部使用 SQL 查询，也支持从外部标准 JDBC/ODBC 连接中进行查询
• Spark SQL 支持 SQL 与常规 Python/Java/Scala 整合，包括连接 RDD 和 SQL 表、公开的自定义 SQL 函数接口等等

Spark SQL 提供特殊的 RDD，SchemaRDD，存放 Row 对象 RDD，每个 Row 对象代表一行记录。

Spark Stream

很多应用需要实时计算，比如可能有些应用需要实时追踪 page view, 然后将数据给 machine learning model 训练，来自动检测异常。Spark Streaming 就是提供这样的功能。

Spark 建立在 RDD 基础上， Spark Streaming 提供了 DStreams 抽象，叫做 discretized streams。DStreams 是一个不断输入的序列数据。在内部，每一个 DStreams 都是时间序列的 RDD，离散的数据。

Spark 运行方式

• 单机运行
• 伪分布式运行
• 分布式运行

在集群中运行 Spark

Spark 可以在各种各样的集群管理器（Hadoop YRAN，Apache Mesos ）中运行。分布式环境下，Spark 集群采用主从结构，一个节点负责中央协调，中央协调节点被称为驱动器 （driver）节点，工作节点被称为执行器（executor）节点，驱动器节点可以和大量执行器节点进行通信，作为独立 Java 进程运行。驱动器节点和执行节点一起被称为一个 Spark 应用（application）。

驱动器节点

驱动器是执行程序 main() 方法的进程。它执行用户编写的 SparkContext，创建 RDD，RDD 转化和行动操作的代码。

驱动器程序在 Spark 下职责：

• 把用户程序转为任务，Spark 把逻辑转化为步骤（stage），每个步骤由多个任务组成，任务被打包送到集群，任务是 Spark 中最小的工作单位
• 为执行器节点调度任务，Spark 驱动器程序吧任务基于数据所在位置分配给合适的执行器进程，驱动器进程会跟踪缓存数据位置，利用这些位置信息来调度任务，减少数据的网络传输

执行器节点

执行器负责 Spark 作业运行任务，任务相互独立。执行器进程的作用：

• 负责运行组成 Spark 应用的任务，并将结果返回给驱动器进程
• 通过自身的块管理器（block Manager）为用户程序中要求缓存的 RDD 提供内存存储

spark-submit 提供工具

Spark 为各种集群管理器提供了统一的工具来提交作业，这个工具是 spark-submit

bin/spark-submit --master spark://host:7077 --executor-memory 10g my_script.py

• --master 标记指定要连接的集群 URL，spark:// 表示集群使用独立模式
• --executor-memory 执行器进程使用的内存量，以字节为单位

Java 和 Scala 可以通过 spark-submit –jars 选项来提交独立的 JAR 包，因为通常都有非常复杂的依赖树，手动维护和提交全部的依赖太过麻烦，常规的做法是通过构建工具，生成单个大 JAR 包，包含应用所有的传递依赖。这个通常被称为超级 JAR（uber）或者组合 JAR（assembly）。Java 和 Scala 最广泛的构建工具是 Maven 和 sbt。

reference

• [1]官方入门文档
• [2]RDD

Kerberos 是一个网络验证协议，通过使用密钥来为 client/server 应用提供高强度的安全校验。一个开源的实现是由 Massachusetts Institute of Technology 实现。Kerberos 也在很多商业产品中被使用。

Kerberos 使用 UDP，默认使用 88 端口

在 Hadoop 生态中涉及到的安全问题可以大致归纳为两类，Authentication 和 Authorization：

• Authentication 认证用户身份，也就是证明 A 是 A 的问题
• Authorization 则是权限控制，A 用户能够做什么操作

Kerberos 解决的问题就是证明 A 是 A 的问题，也就是 Authentication。

Kerberos 中的概念

Kerberos 中必须要了解的概念：

• principle ，可以理解成认证主体，client 和 server 的名字
• realm 是空间， principle 需要在 realm 下
• password， 用户密码，可以存放在 keytab 文件中
• credential 凭据
• Long-term Key ，长期保持不变的 key，比如密码，可能长年不变。Long-term Key 在原则上不应当在网络传输，因为一旦被截获，破解者有足够的时间来破解该密码
• Master Key ，而一般情况下对于一个账户，密码仅限于该账户的所有者知道，这种情况下，通常将密码 Hash，得到一个 hash code，一般将这样的 hash code 叫做 Master key。因为 Hash 算法不可逆，同时能够保证密码和 Master Key 一一对应，既保证了密码的安全性，同时保证了 Master Key 和密码本身可以证明身份。
• Short-term Key or Session Key, 因为 Long-term Key 加密的数据包不能用于网络传输，所以出现了 Short-term Key 用来加密需要网络传输的数据，这一类型的 Key 只在短时间内有效，即使被加密的数据被截获，等将 Key 解密出来时，Key 也早已经过期

Kerberos 中有三种角色：

• KDC：负责分发密钥的密钥分配中心，在 Client 和 Server 之间担任共同信任的角色
• Client：需要使用 kerbores 服务的客户端
• Service：提供具体服务的服务端

认证原理

KDC 分发 Session Key 的过程

Client 如果要获取 Server 资源，先得通过 Server 认证，也就是 Client 需要向 Server 提供从 KDC 获取的带有 Server Master Key 加密的 Session Ticket（Session Key + Client Info). Session Ticket 是 Client 访问 Server 的一张门票，而这张门票需要从合法的 Ticket 发行机构（KDC）获取。同时这张票具有防伪标识（被 Server Master Key 加密过）。

简化一下上面描述的过程，当 Client 要获取 Server 资源时，首先要向 KDC 发送 Session Key 的申请，内容就是，我是某某 Client，我需要访问某某 Server 的 Session Key。KDC 在收到请求后，生成一个 Session Key，为保证 Session Key 仅仅限于发送请求的 Client 和它希望访问的 Server，KDC 会将这个 Session Key 生成两个拷贝，分别被 Client 和 Server 使用，并从数据库中提取 Client 和 Server 的 Master Key 对这两个拷贝进行对称加密，对于 Server 的拷贝还会将 Client 的信息保存到 Session Key。KDC 现在有两个加密过的 Session Key，Kerberos 将这两个拷贝一并发送到 Client。

这边会产生一些问题，比如 KDC 并没有验证这个请求的 Client 是否真的是他自己？但仔细想一下，假如 Client B 假装自己的是 A，那么会得到 Client A 和 Server 的 Session Key，而这时 B 并不知道 A 的 Master Key，所以获得的 Session Key 并不能拿来访问 Server。

认证过程 Authenticator

经过 KDC 分发 Session Key，Client 获得了两个有效信息，一个通过自己的 Master Key 加密的 Session Key，一个被 Server 的 Master Key 加密的数据包（包含 Session Key 和 Client 的信息）

再此基础上，Server 如何认证 Client。首先 Client 通过自己的 Master Key 对 KDC 分发的 Session Key 解密从而获得 Session Key，随后创建 Authenticator（Client Info + Timestamp) 并用 Session Key 对其加密，最后连同从 KDC 获取的被 Server Master Key 加密过得数据包（Client Info + Session Key）一并发送到 Server 段。把通过 Server Master Key 加密过的数据包称为 Session Ticket。

当 Server 接受到两组数据后，用自己的 Master Key 对 Session Ticket 解密，得到 Session Key。然后用该 Session Key 解密 Authenticator，比较 Authenticator 中的 Client Info 和 Session Ticket 中的 Client Info 从而实现对 Client 的认证。Server 需要检查：

• Authenticator 中 Timestamp 是否在当前时间前后 5 分钟内
• 检查 内容是否一致

双向认证

Kerberos 的优势在于能够提供双向认证，Server 可以对 Client 认证，Client 也能够对 Server 进行认证。

如果 Client 需要对访问的 Server 认证，会在向 Server 发送的 Credentials 中设置是否需要认证的 Flag，Server 在对 Client 认证成功后，会把 Authenticator 中 Timestamp 提出来，通过 Session Key 加密发送到 Client，Client 接受并使用 Session Key 解密后，确认 Timestamp 是否一致，从而来判断 Server 是 Client 确定要访问的。

完整认证流程

上面提及的认证流程每次 Client 都要使用自己的 Master Key，为了解决这个问题，Kerberos 引入新角色：Ticket Granting Service（TGS），给 Client 提供用于连接 Server 的票据。这样 Kerberos 就有四个角色。完整的认证流程：

• Client 向 KDC 发出请求，希望和 TGS 通信，请求内容分别为自身的 principle 和 TGS 的 principle
• KDC 收到请求后，通过 Client 和 TGS 的 Master Key 生成两份 Session Key，一份用 Client Master Key 加密的 SKDC-Client，一份 KDC master Key 加密的 TGT
• 客户端用自己的 Master Key 解开 Session Key，然后生成 Authenticator（Client Info + Timestamp)，并给 TGS 发出请求。Client 会缓存 Session 和 TGT，有了 Session Key 和 TGT 之后，Client 就不在需要自己的 Master Key，此后 Client 可以使用 SKDC-Client 向 KDC 申请用来访问 Server 的 Ticker
• TGS 收到 Client 的请求后，用自己的 Master Key 解密 Session Ticket，得到 Session Key，然后用 Session Key 解密 Authenticator 得到 Client Info 和 Timestamp ，校验客户端。通过认证之后，TGS 生成一个 Client 和 Server 的 Session Key，而在此处，TGS 将不再使用 Client 的 Master Key 进行对称加密，而是使用 Client 和 TGS 之间的 Session Key 加密

Ticker 是和具体 Server 相关，而 TGT 则是和具体 Server 无关的，Client 可以使用 TGT 从 KDC 获得不同 Server 的 Ticket。

reference

• https://web.mit.edu/kerberos/
• http://gost.isi.edu/publications/kerberos-neuman-tso.html
• https://en.wikipedia.org/wiki/Kerberos_(protocol)
• https://blog.csdn.net/wulantian/article/details/42418231