KLucenの启示录

问题1：传统的沟通方式无法确定处理的优先级#

例如：使用邮件进行沟通可能出现邮件数量太多导致重要的邮件被埋没，无法管理状态，不知道哪些问题已经解决，哪些问题尚未处理，如果用全文检索邮件的方式来查询相关问题效率过于低下。

解决方案：使用缺陷管理工具。

问题2：没有能够用于验证的环境#

例如：收到项目正式环境中发生的故障报告后，需要还原正式环境需要花费很长的时间。

解决方法：实施持续交付。

问题3：用别名目录管理项目分支#

解决方法：实施版本控制。

问题4：重新制作数据库非常困难#

例如：正式环境和开发环境中数据库表结构不一致或者某个表列的顺序不一致。

解决方法：实施版本控制。

问题5：不运行系统就无法察觉问题#

例如：解决一个bug可能引入其他的bug或者造成系统退化，不正确的使用版本系统覆盖了其他人的修改，修改的内容相互发生了干扰，如果问题不能尽早发现，那么等过去几个月后再想追溯问题就非常麻烦了。

解决方法：实施持续集成，将团队成员的工作成果经常、持续的进行构建和测试。

问题6：覆盖了其他成员修正的代码#

解决方法：实施版本控制。

问题7：无法实施代码重构#

例如：在实施代码重构（在不影响代码产生的结果的前提下对代码内部的构造进行调整）时可能引发退化。

解决方法：大量的可重用的测试并实施持续集成。

问题8：不知道bug的修正日期无法追踪退化#

解决方法：版本控制系统、缺陷管理系统和持续集成之间需要交互，最好能够和自动化部署工具集成到一起来使用。

问题9：发布过程太复杂#

解决方法：实施持续交付。

基于对上述问题的阐述和分析，我们基本上可以得到以下的结论，在团队开发中版本控制、缺陷管理和持续集成都是非常重要且不可或缺的。

Git简介#

Git是诞生于2005年的一个开源分布式版本控制系统，最初是Linus Torvalds（Linux之父） 为了帮助管理Linux内核开发而开发的一个版本控制软件。Git与常用的版本控制工具Subversion等不同，它采用了分布式版本控制的方式，在没有中央服务器支持的环境下也能够实施版本控制。

对于有使用Subversion（以下简称为SVN）经验的人来说，Git和SVN的共同点是摒弃了传统的基于锁定模式的版本控制（早期的CVS和VSS使用了锁定模式，当一个开发者编辑一个文件时会锁定该文件，其他开发者在此期间无法编辑该文件），采用了更有效率的基于合并模式的版本控制，而二者的区别在于：

1. Git是分布式的，SVN是集中式的，SVN需要中央服务器的支持才能工作。
2. Git把内容按元数据方式存储，而SVN是按文件，即把文件的元信息隐藏在一个.svn文件夹里。
3. Git分支和SVN的分支不同，SVN对分支的处理是相当“狗血”的。
4. Git没有一个全局版本号，但是可以自己维护一个版本标签。
5. Git的内容完整性要优于SVN，Git的内容存储使用的是SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。

总而言之，Git真的非常棒！！！

安装Git#

可以在Git官方网站找到适合自己系统的Git下载链接并进行安装，macOS和Windows平台下安装Git都非常简单。

Git本地操作#

可以使用下面的命令将一个文件夹变成Git仓库。

1
git init

当你完成了上述操作后，本地目录就变成了下面的样子，下图左边是你的工作区（正在操作的工作目录），而右边是你的本地仓库，中间是工作区和本地仓库之间的暂存区（也称为缓存区）。

提示：用ls -la查看所有文件会发现在执行完上面的命令后，文件夹下多了一个名为.git的隐藏文件夹，这个就是本地的Git版本仓库。

通过git add可以将指定的文件或所有文件添加到暂存区。

1
git add <file>
2
git add .

这个时候使用下面的命令可以查看工作区、暂存区和本地仓库的状态。

1
git status

提示：如果不希望将文件添加到暂存区，可以按照提示，使用git rm --cached <file>命令将文件从暂存区放回到工作区。

如果这个时候对工作区的文件又进行了修改使得工作区和暂存区的内容并不相同了，再次执行git status可以看到哪个或哪些文件被修改了，如果希望用暂存区的内容恢复工作区，可以使用下面的命令。

1
git restore <file>
2
git restore .

注意：上面的命令目前仍然处于试验性阶段，在Git较早的版本中对应的命令是git checkout -- <file>。由于git checkout这个命令还可以用于切换分支，容易引起混淆，所以Git最新版本中将这个命令的两项功能分别赋予两个新的命令，一个就是上面的git restore，另一个是git switch。

如果第一次使用Git，需要配置用户名和邮箱，然后才能将代码提交到仓库。

1
git config --global user.name "jackfrued"
2
git config --global user.email "jackfrued@126.com"

提示：可以用git config --list来查看Git的配置信息。

通过下面的命令可以将暂存区的内容纳入本地仓库，

1
git commit -m '本次提交的说明'

可以通过git log查看每次提交对应的日志。

1
git log
2
git log --graph --oneline --abbrev-commit

Git服务器概述#

Git不像SVN那样一定需要中央服务器才能工作，上面我们演示的版本控制操作都是在本地执行的，但是对于企业开发多人协作这样的场景还是需要中央服务器的支持。通常，企业可以选择使用代码托管平台（如GitHub）或自己搭建Git私服的方式来建立中央服务器（版本仓库），当然大多数的企业更倾向于后者。Github创办于2008年4月，目前是全世界最大的代码托管平台，支持企业用户（可以创建私有仓库，私有仓库内容不对外界公开）和普通用户（受限的使用私有仓库，不受限的使用公开仓库，公开仓库内容对他人可见）。Github上面代码库惊人的增长速度证明了它是非常成功的，在2018年6月被微软以75亿美元的天价收购。

国内也有不少类似Github的代码托管平台（例如：码云和CODING），目前码云和CODING对注册用户都提供了受限的使用私有仓库的功能，支持Pull Request（一种对话机制，可以在提交你的工作成果时让相关人员或团队注意到这件事情），同时还提供了对缺陷管理、Webhook等功能支持，这些使得版本控制系统还具备了缺陷管理和持续集成的能力。当然，很多公司都不愿意将自己的商业代码托管于别人的平台，这样的公司可以用Gitlab来搭建公司内部的Git私服，具体的做法在下一章为大家介绍。

这里我们直接以码云为例来说明使用Git服务器的一些注意事项。首先需要在码云上注册账号，当然也可以使用第三方登录（github账号、微信账号、新浪微博账号、CSDN账号等），登录成功后就可以创建项目，创建项目几乎是“傻瓜式”的，无需赘述，我们只对几个地方加以说明。

1. 创建项目时不建议勾选如下图所示的这些选项，编程语言可以暂时不做选择，而.gitignore模板也可以稍后自己编写或者通过更专业的工具（如：http://gitignore.io/网站）自动生成。

   

2. 添加项目成员。创建项目后，可以在项目的“设置”或“管理”中找到“成员管理”功能，这样就可以将其他开发者设置为项目团队的成员，项目成员通常分为“所有者”、“管理者”、“普通成员”和“受限成员”几种角色。

   

3. 项目的分支。创建项目后，项目只有一个默认的master分支，应该将该分支设置为“保护分支”来避免项目管理者之外的成员修改该分支（不可直接提交）。当然，如果需要我们也可以在线创建新的代码分支。

4. 设置公钥实现免密访问。在项目的“设置”或“管理”中我们还可以找到“部署公钥管理”的选项，通过添加部署公钥，可以通过SSH（安全远程连接）的方式访问服务器而不用每次输入用户名和口令。可以使用ssh-keygen命令来创建密钥对。

   1
   ssh-keygen -t rsa -b 2048 -C "your_email@example.com"

   说明：上面命令生成的密钥对在~/.ssh目录下，公钥文件默认的名字为id_rsa.pub，可以通过cat id_rsa.pub来查看自己的公钥。Windows用户在安装Git工具后，可以通过Git Bash来输入上面的命令。

Git远程操作#

拥有了Git服务器之后，我们就可以通过Git的远程操作将自己的工作成果推到服务器的仓库中，也可以将他人的工作成果从服务器仓库更新到本地。我们以刚才在码云上创建的仓库（仓库名为python）为例来说明如何进行远程操作。可以在如下所示的页面上找到仓库的地址（URL），如果配置了SSH Key就使用SSH方式访问仓库，否则就用HTTPS方式，后者需要在进行远程操作时提供用户名和口令。

1. 添加远程仓库（Git服务器）。

   1
   git remote add origin git@gitee.com:jackfrued/python.git

   其中git@gitee.com:jackfrued/python.git是上图中显示的仓库的URL，而前面的origin是替代这个冗长的URL的字符串，简单的说origin就是服务器上仓库的别名（如果有多个Git服务器，这个简短的名字也会有多个）。可以用git remote -v来查看已经指定的Git服务，也可以用git remote remove来删除指定的Git服务器。

2. 将本地代码（工作成果）推送到远程仓库。

   1
   git push -u origin master:master

   其中，-u是--set-upstream的缩写，用来指定推送的服务器仓库，后面的origin就是刚才给仓库起的简短的别名，冒号前面的master是本地分支名，冒号后面的master是远程分支名，如果本地分支master已经和远程分支master建立过关联，则冒号以及后面的部分可以省略。

3. 从远程仓库取回代码。

   1
   git pull origin master

Git分支操作#

1. 创建和切换分支。下面的命令创建了名为dev 的分支并切换到该分支。

   1
   git branch <branch-name>
   2
   git switch <branch-name>

   或

   1
   git switch -c <branch-name>

   注意：在之前的Git版本中，切换分支使用git checkout <branch-name>命令，也可以通过git checkout -b <branch-name>来创建并切换分支。git switch命令目前仍然处于试验性阶段，但很明显这个命令更加清晰的表达了它要做的事情。

2. 关联远程分支。例如：如果当前所在的分支还没有关联到远程分支，可以使用下面的命令为它们建立关联。

   1
   git branch --set-upstream-to origin/develop

   如果需要为指定的分支关联远程分支，可以如下操作。

   1
   git branch --set-upstream-to origin/develop <branch-name>

   提示：上面的操作假设Git服务器上存在名为develop的分支，--set-upstream-to可以缩写为-u。

   当然，在创建分支时，如果使用了--track参数，也可以直接指定与本地分支关联的远程分支，如下所示。

   1
   git branch --track <branch-name> origin/develop

   如果需要解除本地分支与远程分支的关联，可以使用下面的命令。

   1
   git branch --unset-upstream <branch-name>

3. 分支合并。例如在dev分支上完成开发任务之后，如果希望将dev分支上的成果合并到master，可以先切回到master分支然后使用git merge来做分支合并，合并的结果如下图右上方所示。

   1
   git switch master
   2
   git merge --no-ff dev

   使用git merge合并分支时，默认使用Fast Forward合并，这意味着如果删除了分支，分支上的信息就全都丢掉了，如果希望将分支上的历史版本保留下来，可以使用--no-ff参数来禁用Fast Forward。

   在合并分支时，没有冲突的部分Git会做自动合并。如果发生了冲突（如dev和master分支上都修改了同一个文件），会看到CONFLICT (content): Merge conflict in <filename>. Automatic merge failed; fix conflicts and then commit the result（自动合并失败，修复冲突之后再次提交）的提示，这个时候我们可以用git diff来查看产生冲突的内容。解决冲突通常需要当事人当面沟通之后才能决定保留谁的版本，冲突解决后需要重新提交代码。

4. 分支变基。分支合并操作可以将多个分支上的工作成果最终合并到一个分支上，但是再多次合并操作之后，分支可能会变得非常的混乱和复杂，为了解决这个问题，可以使用git rebase操作来实现分支变基。如下图所示，当我们希望将master和dev上的工作成果统一到一起的时候，也可以使用变基操作。

   

   1
   git rebase master
   2
   git switch master
   3
   git merge dev

   当我们在dev分支执行git rebase命令时，将首先计算dev分支和master分支的差集，然后应用该差集到dev分支，最后我们切回到master分支并执行操作合并，这样就看到了如上图右下方所示的干净的分支。

5. 删除分支。删除分支可以使用git branch加上-d参数，如果分支上的工作成果还没有合并，那么在删除分支时会看到error: The branch '<branch-name>' is not fully merged.这样的错误提示。如果希望强行删除分支，可以使用-D参数。删除分支的操作如下所示。

   1
   git branch -d <branch-name>
   2
   error: The branch '<branch-name>' is not fully merged.
   3
   If you are sure you want to delete it, run 'git branch -D <branch-name>'.
   4
   git branch -D <branch-name>

   如果要删除远程分支，可以使用下面的命令，但是请慎重的操作。

   1
   git branch -r -d origin/develop
   2
   git push origin :develop

   或者

   1
   git push origin --delete develop

Git其他操作#

1. git fetch：下载远程仓库的所有变动，可以将远程仓库下载到一个临时分支，然后再根据需要进行合并操作，git fetch命令和git merge命令可以看作是之前讲的git pull命令的分解动作。

   1
   git fetch origin master:temp
   2
   git merge temp

2. git diff：常用于比较工作区和仓库、暂存区与仓库、两个分支之间有什么差别。

3. git stash：将当前工作区和暂存区发生的变动放到一个临时的区域，让工作区变干净。这个命令适用于手头工作还没有提交，但是突然有一个更为紧急的任务（如线上bug需要修正）需要去处理的场景。

   1
   git stash
   2
   git stash list
   3
   git stash pop

4. git reset：回退到指定的版本。该命令主要有三个参数，如下图所示。

   

5. git cherry-pick：挑选某个分支的单次提交并作为一个新的提交引入到你当前分支上。

6. git revert：撤回提交信息。

7. git tag：经常用于查看或新增一个标签。

Git工作流程（分支管理策略）#

既然Git是团队开发必备的工具，那么在团队协作时就必须有一个规范的工作流程，这样才能让团队高效的工作，让项目顺利的进展下去，否则工具再厉害但团队成员各自为战，冲突就会无处不在，协作更加无从谈起。我们仍然以刚才码云上创建的python项目为例，来说明Git的分支管理策略。

Git-flow#

除了上述的github-flow分支管理策略外，还有一种名为git-flow的分支管理策略，它也是大多数公司愿意使用的一套流程。Git-flow借鉴了中央集权型版本控制系统的长处，为团队内部统一建立、合并和关闭分支的方法，如下图所示。

在这种模式下，项目有两个长线分支，分别是master和develop，其他都是临时的的辅助分支，包括feature（开发特定功能的分支，开发结束后合并到develop）、release（从develop分离出来的为发布做准备的分支，发布结束后合并到master和develop）和hotfix（产品发布后出现问题时紧急建立的分支，直接从master分离，问题修复后合并到master并打上标签，同时还要合并到develop来避免将来的版本遗漏了这个修复工作，如果此时有正在发布中的release分支，还要合并到release分支）。具体的实施过程如下所示：

1. 最开始的时候只有master和develop分支，如上图左侧所示。

2. 从develop分支创建feature分支（上图右上），工作完成后将工作成果合并到develop分支（上图右中）。

   创建feature分支：

   1
   git switch -c feature/user develop

   或

   1
   git checkout -b feature/user develop

   接下来就是在feature分支上进行开发并实施版本控制，这一段如何操作我们就不再赘述了。工作完成后，将feature分支合并到develop分支：

   1
   git checkout develop
   2
   git merge --no-ff feature/user
   3
   git branch -d feature/user
   4
   git push origin develop

3. 从develop分支创建release分支，发布结束后合并回master和develop分支。

   创建release分支：

   1
   git checkout -b release-0.1 develop
   2
   git push -u origin release-0.1
   3
   ... ... ...
   4
   git pull
   5
   git commit -a -m "............"

   将release分支合并回master和develop分支：

   1
   git checkout master
   2
   git merge --no-ff release-0.1
   3
   git push
   4
   
   5
   git checkout develop
   6
   git merge --no-ff release-0.1
   7
   git push
   8
   
   9
   git branch -d release-0.1
   10
   git push --delete release-0.1
   11
   git tag v0.1 master
   12
   git push --tags

4. 从master分支创建hotfix分支，在修复bug后合并到develop和master分支（上图右下）。

   创建hotfix分支：

   1
   git checkout -b hotfix-0.1.1 master
   2
   git push -u origin hotfix-0.1.1
   3
   ... ... ...
   4
   git pull
   5
   git commit -a -m "............"

   将hotfix分支合并回develop和master分支。

   1
   git checkout master
   2
   git merge --no-ff hotfix-0.1.1
   3
   git push
   4
   
   5
   git checkout develop
   6
   git merge --no-ff hotfix-0.1.1
   7
   git push
   8
   
   9
   git branch -d hotfix-0.1.1
   10
   git push --delete hotfix-0.1.1
   11
   git tag v0.1.1 master
   12
   git push --tags

Git-flow流程比较容易控制各个分支的状况，但是在运用上github-flow要复杂得多，因此实际使用的时候通常会安装名为gitflow的命令行工具（Windows环境的Git自带了该工具）或者使用图形化的Git工具（如：SmartGit、SourceTree等）来简化操作，具体的可以参考《git-flow 的工作流程》一文，因为这篇文章写得已经很好了，本文不再进行赘述。

禅道#

禅道是国产的专业项目管理软件，它不仅仅是缺陷管理工具，它提供了完整软件生命周期管理功能，支持Scrum敏捷开发，能够实现需求管理、缺陷管理、任务管理等一系列的功能，而且拥有强大的扩展机制和丰富的功能插件。可以从禅道的官方网站提供的下载链接来下载禅道，推荐使用一键安装包。

下面仍然以CentOS Linux为例，讲解如何利用官方提供的一键安装包来安装禅道。

1
cd /opt
2
wget http://dl.cnezsoft.com/zentao/pro8.5.2/ZenTaoPMS.pro8.5.2.zbox_64.tar.gz
3
gunzip ZenTaoPMS.pro8.5.2.zbox_64.tar.gz
4
tar -xvf ZenTaoPMS.pro8.5.2.zbox_64.tar

我们在/opt目录下（官方推荐使用这个目录）下载了禅道的归档压缩文件，并进行了解压缩和解归档的操作，完成上述步骤后，会看到一个名为zbox的文件夹。一键安装包中内置了Apache、MySQL、PHP等应用，也就是说这些都不需要单独安装部署了，接下来我们通过下面的命令来启动禅道。

1
/opt/zbox/zbox -ap 8080 -mp 3307
2
/opt/zbox/zbox start

说明：上面使用zbox文件夹下的zbox命令，其中-ap是为了指定Apache服务器使用的端口，-mp是为了指定MySQL数据库使用的端口，这里使用3307端口是为了避开服务器上可能已经存在的MySQL服务的3306端口；start表示启动服务，stop可以用来停止服务。此外，需要打开防火墙8080端口以便访问禅道，注意数据库的端口决不能暴露给公网。

打开浏览器，输入服务器的公网IP地址就可以访问禅道，如果愿意，也可以通过DNS解析绑定一个域名来进行访问，禅道的首页如下图所示，默认的管理员是admin，口令是123456。

第一次使用禅道时，建议通过点击用户名，然后通过“帮助”菜单的“新手教程”来迅速了解禅道。官方网站的文档链接中提供了视频教程，初学者也可以通过视频教程来上手。

对敏捷开发以及敏捷闭环工具不是特别了解的，可以参考《基于JIRA的Scrum敏捷开发的项目管理》一文。

GitLab#

常用的代码托管平台和之前提到的Git私服Gitlab都提供了缺陷管理的功能，当我们要报告一个bug时，可以在如下图所示的界面创建一个新的问题票（issue ticket）。填写的内容包括：

1. **[必填]**出现问题的软件版本号、具体的使用环境（如操作系统）等相关信息。
2. **[必填]**能够稳定重现该问题的相关步骤。
3. **[必填]**描述此处期待的行为和实际的行为。
4. **[可选]**你对这个bug的看法（产生bug的原因是什么）。

如上图所示，我们在创建问题票时，还需要将问题指派给处理问题的人，如果不清楚应该由谁来修复这个bug，就指派给项目管理者，除此之外还要指定问题的优先级（十分紧急、紧急、普通、不紧急等）、问题的标签（功能缺陷、新特性、改进增强、前瞻研究等）、里程碑（通过里程碑可以将问题与某些特定的项目节点关联起来，之后可以查看每一个里程碑的进展，可以基于软件版本号来建立里程碑，也可以基于迭代周期来建立里程碑）以及需要在哪个时间点以前修复等信息。

有些敏捷团队使用问题票来管理产品的需求，称之为“问题驱动开发”（TiDD），也就是说新功能的开发是通过创建问题票来驱动的，具体的步骤包括：建立问题票、指定责任人、开发、提交、Push到代码库。如果要创建一个和需求相关的问题票，应该要填写以下的内容：

1. **[必填]**简短的描述需求，并用它作为标题。
2. **[必填]**这个需求是解决什么问题的。
3. **[必填]**这个需求对软件现有功能会造成什么影响。
4. **[必填]**这个需求应该实现什么样的功能。
5. **[必填]**这个需求是否依赖其他模块提供相关支持。
6. **[可选]**这个需求有哪些实现方式。
7. **[可选]**这些可选的实现方式分别有哪些优缺点。

其他产品#

除了禅道和GitLab之外，JIRA、Redmine、Backlog等也是不错的缺陷管理系统。目前，这些系统大都不仅仅提供了缺陷管理的功能，更多的时候它们可以作为敏捷闭环工具来使用，关于敏捷闭环工具这个话题，请大家参考《基于JIRA的Scrum敏捷开发的项目管理》一文。

运行Nginx#

Nginx是高性能的Web服务器，同时也是做反向代理服务器的上佳选择。使用Docker可以非常简单的创建一个运行Nginx的容器，命令如下所示。

1
docker container run -d -p 80:80 --rm --name mynginx nginx

说明：上面的参数-d表示容器在后台运行（不产生输出到Shell）并显示容器的ID；-p是用来映射容器的端口到宿主机的端口，冒号前面是宿主机的端口，冒号后面是容器内部使用的端口；--rm表示容器停止后自动删除容器，例如执行命令docker container stop mynginx后，容器就不复存在了；--name后面的mynginx是自定义的容器名字；在创建容器的过程中，需要用到nginx的镜像文件，镜像文件的下载是自动完成的，如果没有指定版本号，默认是最新版本（latest）。

如果需要将自己的Web项目（页面）部署到Nginx上，可以使用容器拷贝命令将指定路径下所有的文件和文件夹拷贝到容器的指定目录中。

1
docker container cp /root/web/index.html mynginx:/usr/share/nginx/html

如果不愿意拷贝文件也可以在创建容器时通过数据卷操作--volume将指定的文件夹映射到容器的某个目录中，例如将Web项目的文件夹直接映射到/usr/share/nginx/html目录。我们先通过下面的命令让刚才创建的容器停止运行。

1
docker container stop mynginx

然后用下面的命令重新创建容器。

1
docker container run -d -p 80:80 --rm --name mynginx --volume /root/docker/nginx/html:/usr/share/nginx/html nginx

说明：上面创建容器和拷贝文件的命令中，container是可以省略的，也就是说docker container run和docker run是一样的，而docker container cp和docker cp是一样的。此外，命令中的--volume也可以缩写为-v，就如同-d是--detach的缩写，-p是--publish的缩写。$PWD代表宿主系统当前文件夹，这些对于使用过Unix或者Linux系统的人来说，应该是很容易理解的。

要查看运行中的容器，可以使用下面的命令。

1
docker ps

1
CONTAINER ID    IMAGE    COMMAND                  CREATED            STATUS             PORTS                 NAMES
2
3c38d2476384    nginx    "nginx -g 'daemon ..."   4 seconds ago      Up 4 seconds       0.0.0.0:80->80/tcp    mynginx

要启动和停止容器，可以使用下面的命令。

1
docker start mynginx
2
docker stop mynginx

由于在创建容器时使用了--rm选项，容器在停止时会被移除，当我们使用下面的命令查看所有容器时，应该已经看不到刚才的mynginx容器了。

1
docker container ls -a

如果在创建容器时没有指定--rm选项，那么也可以使用下面的命令来删除容器。

1
docker rm mynginx

要删除正在运行中的容器，需要使用-f选项。

1
docker rm -f mynginx

运行MySQL#

我们再来尝试用Docker安装一台MySQL服务器，首先可以先检查一下有没有MySQL的镜像文件。

1
docker search mysql

1
INDEX        NAME            DESCRIPTION        STARS        OFFICIAL        AUTOMATED
2
docker.io    docker.io/mysql MySQL is a ...     8486         [OK]
3
...

说明：上面查询结果的列依次代表索引、镜像名、镜像描述、用户评价、是否官方镜像、自动构建。

下载MySQL镜像并指定镜像的版本号。

1
docker pull mysql:5.7

如果需要查看已经下载的镜像文件，可以使用下面的命令。

1
docker images

1
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
2
docker.io/nginx     latest              e445ab08b2be        2 weeks ago         126 MB
3
docker.io/mysql     5.7                 f6509bac4980        3 weeks ago         373 MB

创建并运行MySQL容器。

1
docker run -d -p 3306:3306 --name mysql57 -v /root/docker/mysql/conf:/etc/mysql/mysql.conf.d -v /root/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

注意：上面创建容器时我们又一次使用了数据卷操作，那是因为通常容器是随时创建随时删除的，而数据库中的数据却是需要保留下来的。

上面的两个数据卷操作一个是映射了MySQL配置文件所在的文件夹，一个是映射了MySQL数据所在的文件夹，这两个数据卷操作非常重要。我们可以将MySQL的配置文件放在$PWD/mysql/conf目录下，配置文件的具体内容如下所示：

1
[mysqld]
2
pid-file=/var/run/mysqld/mysqld.pid
3
socket=/var/run/mysqld/mysqld.sock
4
datadir=/var/lib/mysql
5
log-error=/var/log/mysql/error.log
6
server-id=1
7
log-bin=/var/log/mysql/mysql-bin.log
8
expire_logs_days=30
9
max_binlog_size=256M
10
symbolic-links=0

如果安装了MySQL 8.x版本（目前的最新版本），在使用客户端工具连接服务器时可能会遇到error 2059: Authentication plugin 'caching_sha2_password' cannot be loaded的问题，这是因为MySQL 8.x默认使用了名为“caching_sha2_password”的机制对用户口令进行了更好的保护，但是如果客户端工具不支持新的认证方式，连接就会失败。解决这个问题有两种方式：一是升级客户端工具来支持MySQL 8.x的认证方式；二是进入容器，修改MySQL的用户口令认证方式。下面是具体的步骤，我们先用docker exec命令进入容器的交互式环境，假设运行MySQL 8.x的容器名字叫mysql8x。

1
docker exec -it mysql8x /bin/bash

进入容器的交互式Shell之后，可以首先利用MySQL的客户端工具连接MySQL服务器。

1
mysql -u root -p
2
Enter password:
3
Your MySQL connection id is 16
4
Server version: 8.0.12 MySQL Community Server - GPL
5
Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
6
Oracle is a registered trademark of Oracle Corporation and/or its
7
affiliates. Other names may be trademarks of their respective
8
owners.
9
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
10
mysql>

接下来通过SQL来修改用户口令就可以了。

1
alter user 'root'@'%' identified with mysql_native_password by '123456' password expire never;

当然，如果愿意你也可以查看一下用户表检查是否修改成功。

1
use mysql;
2
select user, host, plugin, authentication_string from user where user='root';
3
+------+-----------+-----------------------+-------------------------------------------+
4
| user | host      | plugin                | authentication_string                     |
5
+------+-----------+-----------------------+-------------------------------------------+
6
| root | %         | mysql_native_password | *6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9 |
7
| root | localhost | mysql_native_password | *6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9 |
8
+------+-----------+-----------------------+-------------------------------------------+
9
2 rows in set (0.00 sec)

在完成上面的步骤后，现在即便不更新客户端工具也可以连接MySQL 8.x了。

运行Redis#

接下来我们试一试运行多个容器并让多个容器之间通过网络通信。我们创建4个Redis容器来实现一主三从的主从复制结构。

1
docker run -d -p 6379:6379 --name redis-master redis
2
docker run -d -p 6380:6379 --name redis-slave-1 --link redis-master:redis-master redis redis-server --replicaof redis-master 6379
3
docker run -d -p 6381:6379 --name redis-slave-2 --link redis-master:redis-master redis redis-server --replicaof redis-master 6379
4
docker run -d -p 6382:6379 --name redis-slave-3 --link redis-master:redis-master redis redis-server --replicaof redis-master 6379

上面的命令中，--link参数用于给容器创建网络别名，因为三台从机（slave）需要通过网络连接自己的主机（master）。虽然，我们可以通过docker inspect --format '{{ .NetworkSettings.IPAddress }}' <container-ID>命令来查看到容器的IP地址，但是由于容器的即装即用性，容器的IP地址有可能会发生变化，如果直接使用IP地址，在容器重启后就可能会因为IP地址的变化导致从机无法连接到主机。使用--link参数创建网络别名就是为了在启动Redis服务器时在redis-server后面的--replicaof参数后使用这个别名而不是IP地址。

接下来我们进入名为redis-master的容器，看看主从复制的配置是否成功。

1
docker exec -it redis-master /bin/bash

通过redis-cli启动命令行工具。

1
redis-cli
2
127.0.0.1:6379> info replication
3
# Replication
4
role:master
5
connected_slaves:3
6
slave0:ip=172.17.0.4,port=6379,state=online,offset=1988,lag=0
7
slave1:ip=172.17.0.5,port=6379,state=online,offset=1988,lag=1
8
slave2:ip=172.17.0.6,port=6379,state=online,offset=1988,lag=1
9
master_replid:94703cfa03c3ddc7decc74ca5b8dd13cb8b113ea
10
master_replid2:0000000000000000000000000000000000000000
11
master_repl_offset:1988
12
second_repl_offset:-1
13
repl_backlog_active:1
14
repl_backlog_size:1048576
15
repl_backlog_first_byte_offset:1
16
repl_backlog_histlen:1988

运行GitLab#

GitLab是由GitLab Inc.开发的Git仓库管理工具，具有wiki、问题跟踪、持续集成等一系列的功能，分为社区版和企业版。通过Docker提供的虚拟化容器，我们可以安装社区版的Docker。因为GitLab需要使用SSH协议进行安全连接，我们要暴露容器的22端口，所以可以先将宿主机SSH连接的22端口修改为其他端口（如：12345），然后再进行后续的操作。

1
vim /etc/ssh/sshd_config

将其中定义端口的那行代码去掉注释并将端口修改为12345。

1
Port 12345

重新启动sshd服务。

1
systemctl restart sshd

提示：修改端口后应该确保防火墙上也开启对应的端口，否则无法使用SSH连接到Linux服务器。

创建需要用于数据卷映射操作的文件夹。

1
mkdir -p /root/gitlab/{config,logs,data}

基于gitlab/gitlab-ce镜像创建容器，并暴露80端口（HTTP连接）和22端口（SSH连接）。

1
docker run -d -p 80:80 -p 22:22 --name gitlab -v /root/gitlab/config:/etc/gitlab -v /root/gitlab/logs:/var/log/gitlab -v /root/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce

说明：GitLab的启动比较缓慢，创建好容器后可能需要等待一段时间才能通过浏览器来进行访问。

首次进入GitLab访问界面会提示我们修改管理员密码，设置好管理员密码后就可以在登录界面输入用户名root和刚才设置的密码登录到管理员控制台，在使用上还是非常简单和人性化的。

使用commit命令构建镜像#

为了演示如何构建镜像，我们先使用Ubuntu镜像来定制一个容器，命令如下所示。

1
docker run --name myubuntu -it ubuntu /bin/bash

在容器中执行下面的命令来安装Apache服务器并退出容器。

1
apt -y upgrade
2
apt -y install apache2
3
exit

我们将这个容器作为一个定制的Web服务器保存起来，当需要这样一台Web服务器的时候，就没有必要重新创建容器并安装Apache了。

首先我们通过下面的命令查看容器的ID。

1
docker container ls -a

1
docker container ls -a
2
CONTAINER ID    IMAGE    COMMAND        CREATED        STATUS        PORTS    NAMES
3
014bdb321612    ubuntu   "/bin/bash"    5 minutes ago  Exited (0)             myubuntu

提交定制的容器。

1
docker commit 014bdb321612 jackfrued/mywebserver

查看镜像文件。

1
docker images

1
REPOSITORY              TAG       IMAGE ID        CREATED             SIZE
2
jackfrued/mywebserver   latest    795b294d265a    14 seconds ago      189 MB

生成镜像文件以后，后面就可以利用刚才创建的镜像文件来创建新的容器。

使用Dockerfile构建镜像#

Dockerfile使用DSL（Domain Specific Language）来构建一个Docker镜像，只要编辑好了Dockerfile文件，就可以使用docker build命令来构建一个新的镜像。

我们先创建一个名为myapp的文件夹来保存项目代码和Dockerfile的文件，如下所示：

1
[ECS-root temp]# tree myapp
2
myapp
3
├── api
4
│   ├── app.py
5
│   ├── requirements.txt
6
│   └── start.sh
7
└── Dockerfile

其中api是Flask项目的文件夹，其中包括了项目代码、依赖项以及启动脚本等文件，具体内容如下所示：

app.py文件：

1
from flask import Flask
2
from flask_restful import Resource, Api
3
from flask_cors import CORS
4

5
app = Flask(__name__)
6
CORS(app, resources={r'/api/*': {'origins': '*'}})
7
api = Api(app)
8

9

10
class Product(Resource):
11

12
    def get(self):
13
        products = ['Ice Cream', 'Chocolate', 'Coca Cola', 'Hamburger']
14
        return {'products': products}
15

16

17
api.add_resource(Product, '/api/products')

requirements.txt文件：

1
flask
2
flask-restful
3
flask-cors
4
gunicorn

start.sh文件：

1
#!/bin/bash
2
exec gunicorn -w 4 -b 0.0.0.0:8000 app:app

提示：需要给start.sh文件以执行权限，可以使用chmod 755 start.sh命令来做到。

Dockerfile文件：

1
# 指定基础镜像
2
FROM python:3.7
3
# 指定镜像的维护者
4
MAINTAINER jackfrued "jackfrued@126.com"
5
# 将指定文件添加到容器中指定的位置
6
ADD api/* /root/api/
7
# 设置工作目录
8
WORKDIR /root/api
9
# 执行命令(安装Flask项目的依赖项)
10
RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple/
11
# 容器启动时要执行的命令
12
ENTRYPOINT ["./start.sh"]
13
# 暴露端口
14
EXPOSE 8000

我们来解释一下上面的Dockerfile文件。Dockerfile文件通过特殊的指令来指定基础镜像（FROM指令）、创建容器后需要指定的命令（RUN指令）以及需要暴露的端口（EXPOSE）等信息。我们稍后会专门为大家介绍这些Dockfile中的指令。

接下来我们可以使用docker build命令来创建镜像，如下所示。

1
docker build -t "jackfrued/myapp" .

提示：上面的命令最后面的. 千万不要漏掉了哦，它表示从当前路径下寻找Dockerfile。

通过下面的命令可以查看创建好的镜像。

1
docker images

1
REPOSITORY                   TAG                 IMAGE ID            CREATED             SIZE
2
jackfrued/myapp              latest              6d6f026a7896        5 seconds ago       930 MB

如果想知道镜像文件是如何创建出来的，可以使用下面的命令。

1
docker history jackfrued/myapp

1
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
2
6d6f026a7896        31 seconds ago      /bin/sh -c #(nop)  EXPOSE 8000/tcp              0 B
3
3f7739173a79        31 seconds ago      /bin/sh -c #(nop)  ENTRYPOINT ["./start.sh"]    0 B
4
321e6bf09bf1        32 seconds ago      /bin/sh -c pip install -r requirements.txt...   13 MB
5
2f9bf2c89ac7        37 seconds ago      /bin/sh -c #(nop) WORKDIR /root/api             0 B
6
86119afbe1f8        37 seconds ago      /bin/sh -c #(nop) ADD multi:4b76f9c9dfaee8...   870 B
7
08d465e90d4d        3 hours ago         /bin/sh -c #(nop)  MAINTAINER jackfrued "j...   0 B
8
fbf9f709ca9f        12 days ago         /bin/sh -c #(nop)  CMD ["python3"]              0 B

使用该镜像来创建容器运行Web服务器。

1
docker run -d -p 8000:8000 --name myapp jackfrued/myapp

如果希望将上面创建的镜像文件放到dockerhub仓库中，可以按照如下所示的步骤进行操作。

通过下面的命令登录到dockerhub。

1
docker login

输入用户名和口令进行登录。

1
Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
2
Username: jackfrued
3
Password:
4
Login Succeeded

通过下面的命令将镜像推到仓库中。

1
docker push jackfrued/webserver

Dockerfile指令#

想了解Dockerfile的指令可以查看官方提供的参考手册，下面我们为大家介绍一些常用的指令。

1. FROM：设置基础镜像，必须是Dockerfile中的第一条指令。

   1
   FROM <镜像名> [AS <别名>]

   或

   1
   FROM <镜像名>[:<标签>] [AS <别名>]

2. RUN：指定构建镜像时要执行的命令。

   1
   RUN <命令> [参数1], [参数2], ...

   或

   1
   RUN ["可执行文件", "参数1", "参数2", ...]

3. CMD：指定构建镜像后要执行的命令。

   1
   CMD <命令> [参数1], [参数2], ...

   或

   1
   CMD ["可执行文件", "参数1", "参数2", ...]

   说明：Docker不同于虚拟机，容器本身就是一个进程，容器中的应用应该位于前台运行。CMD命令相当于就是用来指定容器主进程（创建容器后要在前台执行的程序）的，如果主进程结束了，容器也就停止运行了。所以在容器中启动Nginx不能使用service nginx start或是systemctl start nginx而是要通过CMD ["nginx", "-g", "daemon off;"]让它在前台运行。

4. ENTRYPOINT：和CMD类似，也可以执行命令，但docker run命令行中指定的任何参数都会被当做参数再次传给ENTRYPOINT指令中的命令，这就使得我们可以构建一个镜像，它既可以运行一个默认的命令，也支持通过docker run命令行为该命令指定可覆盖的参数选项。

   1
   ENTRYPOINT <命令> [参数1], [参数2], ...

   或

   1
   ENTRYPOINT ["可执行文件", "参数1", "参数2", ...]

5. WORKDIR：在通过镜像创建新容器时，在容器内部创建一个工作目录，ENTRYPOINT和CMD指定的程序会在这个目录下执行。在使用docker run命令时可以通过-w参数来覆盖由WORKDIR指定的工作目录。例如：

   1
   WORKDIR /opt/webapp

   1
   docker run -w /usr/share/webapp ...

6. ENV：在创建镜像时设置环境变量。在使用docker run命令时，可以通过-e参数来修改环境变量的设置。例如：

   1
   ENV DEFAULT_PORT=8080

   1
   docker run -e "DEFAULT_PORT=8000" ...

7. USER：指定镜像会以什么用户身份去运行。例如：

   1
   USER nginx

8. VOLUME：在创建容器时添加一个数据卷的挂载点。通过数据卷操作可以实现容器间数据的共享和重用，对卷所作的修改可以马上生效而不需要重新启动容器，我们之前创建容器时使用--volume参数就是为了实现数据卷的映射操作。

   1
   VOLUME ["/路径1", "/路径2/子路径2.1/", ...]

9. ADD：将构建目录下的文件和文件夹复制到镜像中，如果是压缩文件和归档文件，ADD命令会对这些文件进行解压缩解归档的操作。

   1
   ADD [--chown=<用户>:<用户组>] <源文件> <目标文件>

10. COPY：非常类似于ADD，但不会主动对文件进行提取操作。

11. LABEL：为Docker镜像添加一些元数据，在使用docker inspect命令时会看到这些元数据。

    1
    LABEL version="1.0.0" location="Chengdu"

12. ONBUILD：为镜像添加触发器，当一个镜像被用作其他镜像的基础镜像，触发器将会被执行。例如：

    1
    ONBUILD ADD . /app/src
    2
    ONBUILD RUN cd /app/src && make

Docker Compose#

可以通过安装Docker Compose工具来实现基于YAML文件的容器编排，YAML文件会定义一系列的容器以及容器运行时的属性，Docker Compose会根据这些配置来管理容器。

1. 安装Docker Compose。

   1
   curl -L "https://github.com/docker/compose/releases/download/1.25.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
   2
   chmod +x /usr/local/bin/docker-compose

   说明：如果没有curl工具，在CentOS下可以先通过包管理工具yum安装curl再执行上面的命令。

   当然我们也可以使用Python的包管理工具pip来安装Docker Compose，命令如下所示。

   1
   pip3 install -U docker-compose

2. 使用Docker Compose。

   我们在刚才的Flask项目中引入缓存，然后再利用Flask提供的数据接口为前端页面提供数据，使用Vue.js进行页面渲染并将静态页面部署在Nginx服务器上。项目文件夹结构如下所示：

   1
   [ECS-root ~]# tree temp
   2
   temp
   3
   ├── docker-compose.yml
   4
   ├── html
   5
   │   └── index.html
   6
   └── myapp
   7
       ├── api
   8
       │   ├── app.py
   9
       │   ├── requirements.txt
   10
       │   └── start.sh
   11
       └── Dockerfile

   修改后的app.py文件代码如下所示：

   1
   from pickle import dumps, loads
   2
   
   3
   from flask import Flask
   4
   from flask_restful import Resource, Api
   5
   from flask_cors import CORS
   6
   from redis import Redis
   7
   
   8
   app = Flask(__name__)
   9
   CORS(app, resources={r'/api/*': {'origins': '*'}})
   10
   api = Api(app)
   11
   redis = Redis(host='redis-master', port=6379)
   12
   
   13
   
   14
   class Product(Resource):
   15
   
   16
       def get(self):
   17
           data = redis.get('products')
   18
           if data:
   19
               products = loads(data)
   20
           else:
   21
               products = ['Ice Cream', 'Chocolate', 'Coca Cola', 'Hamburger']
   22
               redis.set('products', dumps(products))
   23
           return {'products': products}
   24
   
   25
   
   26
   api.add_resource(Product, '/api/products')

   html文件夹用来保存静态页面，稍后我们会通一个运行Nginx的容器来向浏览器提供静态页面。index.html文件的内容如下所示：

   1
   <!DOCTYPE html>
   2
   <html lang="en">
   3
   <head>
   4
       <meta charset="utf-8">
   5
       <title>首页</title>
   6
   </head>
   7
   <body>
   8
       <div id="app">
   9
           <h2>产品列表</h2>
   10
           <ul>
   11
               <li v-for="product in products">{{ product }}</li>
   12
           </ul>
   13
       </div>
   14
       <script src="https://cdn.bootcss.com/vue/2.6.10/vue.min.js"></script>
   15
       <script>
   16
           new Vue({
   17
               el: '#app',
   18
               data: {
   19
                   products: []
   20
               },
   21
               created() {
   22
                   fetch('http://1.2.3.4:8000/api/products')
   23
                       .then(resp => resp.json())
   24
                       .then(json => {this.products = json.products})
   25
               }
   26
           })
   27
       </script>
   28
   </body>
   29
   </html>

   接下来，我们要通过docker-compose.yml文件来创建三个容器并指明容器之间的依赖关系。

   1
   version: '3'
   2
   services:
   3
     api-server:
   4
       build: ./myapp
   5
       ports:
   6
         - '8000:8000'
   7
       links:
   8
         - redis-master
   9
     web-server:
   10
       image: nginx
   11
       ports:
   12
         - '80:80'
   13
       volumes:
   14
         - ./html:/usr/share/nginx/html
   15
     redis-master:
   16
       image: redis
   17
       expose:
   18
         - '6379'

   有了这个YAML文件，我们就可以使用docker-compose命令来创建容器运行项目，其命令如下所示：

   1
   [ECS-root temp]# docker-compose up
   2
   Creating network "temp_default" with the default driver
   3
   Creating temp_web-server_1   ... done
   4
   Creating temp_redis-master_1 ... done
   5
   Creating temp_api-server_1   ... done
   6
   Attaching to temp_redis-master_1, temp_web-server_1, temp_api-server_1
   7
   redis-master_1  | 1:C 05 Dec 2019 11:57:26.828 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
   8
   redis-master_1  | 1:C 05 Dec 2019 11:57:26.828 # Redis version=5.0.6, bits=64, commit=00000000, modified=0, pid=1, just started
   9
   redis-master_1  | 1:C 05 Dec 2019 11:57:26.828 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
   10
   redis-master_1  | 1:M 05 Dec 2019 11:57:26.830 * Running mode=standalone, port=6379.
   11
   redis-master_1  | 1:M 05 Dec 2019 11:57:26.831 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
   12
   redis-master_1  | 1:M 05 Dec 2019 11:57:26.831 # Server initialized
   13
   redis-master_1  | 1:M 05 Dec 2019 11:57:26.831 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
   14
   redis-master_1  | 1:M 05 Dec 2019 11:57:26.831 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
   15
   redis-master_1  | 1:M 05 Dec 2019 11:57:26.831 * Ready to accept connections
   16
   api-server_1    | [2019-12-05 11:57:27 +0000] [1] [INFO] Starting gunicorn 20.0.4
   17
   api-server_1    | [2019-12-05 11:57:27 +0000] [1] [INFO] Listening at: http://0.0.0.0:8000 (1)
   18
   api-server_1    | [2019-12-05 11:57:27 +0000] [1] [INFO] Using worker: sync
   19
   api-server_1    | [2019-12-05 11:57:27 +0000] [8] [INFO] Booting worker with pid: 8
   20
   api-server_1    | [2019-12-05 11:57:27 +0000] [9] [INFO] Booting worker with pid: 9
   21
   api-server_1    | [2019-12-05 11:57:27 +0000] [10] [INFO] Booting worker with pid: 10
   22
   api-server_1    | [2019-12-05 11:57:27 +0000] [11] [INFO] Booting worker with pid: 11

   要停止容器的运行，可以使用下面的命令。

   1
   docker-compose down

Kubernetes（K8S）#

实际的生产环境中常常需要部署和管理多个协同工作的容器，docker compose解决了多容器创建和管理的问题，但是实际项目中，我们还需要Kubernetes（以下都简称为K8S）来提供一个跨主机集群的容器调度平台。K8S可以进行自动化容器的部署、扩展和操作，从而提供以容器为中心的基础架构。该项目是谷歌在2014年启动的项目，建立在谷歌公司十余年运维经验的基础之上，而且谷歌自己的应用也是运行在容器上的。

InnoDB表的注意事项#

1. 主键列使用unsigned整数，可以使用auto_increment，但是要禁止手动更新主键。
2. 每个列都必须添加comment注释。
3. 在建表时必须显示指定engine。
4. 表必备三字段：xxx_id、 xxx_create、 xxx_modified。其中xxx_id为主键，类型unsigned整数类型（例如：int unsigned）；xxx_create、xxx_modified的类型均为datetime类型，分别记录该条数据的创建时间、修改时间。
5. 所有字段必须指定not null，为空值指定default值，因为MySQL难以优化null值，含null值的复合索引会失效，最终导致查询效率低。
6. 单张表的字段数尽量空值在50个字段以内，如果字段过多可以考虑垂直拆分。
7. 禁用enum和set类型，因为这样的类型兼容性不好且性能较差。
8. 大文件不应该使用blob类型而是保存它们的路径，blob和text这样的类型会导致处理性能下降，全表扫描代价大大增加。
9. 对货币等对精度敏感的数据，应该使用定点数（decimal）而不是浮点数（float）。
10. 保存IP地址不要用char(15)，应该使用int unsigned，可以使用inet_aton和inet_ntoa函数实现整数和IP地址的转换。

索引的设计原则#

1. 创建索引的列并不一定是select操作中要查询的列，最适合做索引的列是出现在where子句中经常用作筛选条件或连表子句中作为表连接条件的列。
2. 具有唯一性的列，索引效果好；重复值较多的列，索引效果差。
3. 如果为字符串类型创建索引，最好指定一个前缀长度，创建短索引。短索引可以减少磁盘I/O而且在做比较时性能也更好，更重要的是MySQL底层的高速索引缓存能够缓存更多的键值。
4. 创建一个包含N列的复合索引（多列索引）时，相当于是创建了N个索引，此时应该利用最左前缀进行匹配。
5. 不要过度使用索引。索引并不是越多越好，索引需要占用额外的存储空间而且会影响写操作的性能（插入、删除、更新数据时索引也需要更新）。MySQL在生成执行计划时，要考虑各个索引的使用，这个也是需要耗费时间的。
6. 要注意可能使索引失效的场景，例如：模糊查询使用了前置通配符、使用负向条件进行查询等。

关键问题#

为移动端或者PC端设计网络API接口一个非常重要的原则是：根据业务实体而不是用户界面或操作来设计API接口。如果API接口的设计是根据用户的操作或者界面上的功能设置来设计，随着需求的变更，用户界面也会进行调整，需要的数据也在发生变化，那么后端开发者就要不停的调整API，或者给一个API设计出多个版本，这些都会使项目的开发和维护成本增加。我们可以将业务实体理解为服务器提供的资源，而URL就是资源的定位符（标识符），这种方式是最为简单自然的。对于相对复杂的用户操作，我们可以提供一个“门面”（设计模式中的“门面模式”），通过该“门面”把多个接口的功能组装起来即可。

下面是某个网站开放API的接口，可以看出API的设计是围绕业务实体来进行的，而且都做到了“见名知意”。

需要说明的是，上面的API接口并不是REST风格的。REST是一种网络应用架构风格，被认为最适合分布式的网络应用。关于REST的知识，可以阅读阮一峰的《理解RESTful架构》以及《RESTful API设计指南》，当然这两篇文章大家也要批判的阅读，因为上面阐述的观点并不完全正确，有些内容甚至是自相矛盾的。

API接口返回的数据通常都是JSON或XML格式，XML这种数据格式目前基本已经被弃用了。对于JSON格式的数据，我们需要做到不要返回null这的值，因为这样的值一旦处置失当，会给前端和移动端开发带来不必要的麻烦（因为开发者有可能会使用强类型语言）。要解决这个问题可以从源头入手，在设计数据库的时候，尽量给每个字段都加上“not null”约束或者设置合理的默认值约束。

其他问题#

1. 更新提示问题：设计一个每次使用系统首先要访问的API，该API会向移动端返回系统更新的相关信息，这样就可以提升用户更新App了。
2. 版本升级问题：API版本升级时应该考虑对低版本的兼容，同时要让新版本和旧版本都能够被访问，可以在URL中包含版本信息或者在将版本号放在HTTP(S)协议头部，关于这个问题有很多的争论，有兴趣的可以看看stack overflow上面对这个问题的讨论。
3. 图片尺寸问题：移动端对于一张图片可能需要不同的尺寸，可以在获取图片时传入尺寸参数并获取对应的资源；更好的做法是直接使用云存储或CDN（直接提供了图片缩放的功能），这样可以加速对资源的访问。

HTTP请求 = 请求行+请求头+空行+[消息体]#

HTTP响应 = 响应行+响应头+空行+消息体#

1. HTTPRequest对象的属性和方法：

   • method - 获取请求方法
   • path / get_full_path() - 获取请求路径/带查询字符串的路径
   • scheme / is_secure() / get_host() / get_port() - 获取请求的协议/主机/端口
   • META / COOKIES - 获取请求头/Cookie信息
   • GET / POST / FILES - 获取GET或POST请求参数/上传的文件
   • get_signed_cookie() - 获取带签名的Cookie
   • is_ajax() - 是不是Ajax异步请求
   • body / content_type / encoding - 获取请求的消息体（bytes流）/MIME类型/编码

2. 中间件添加的属性：

   • session / user / site

3. HttpResponse对象的属性和方法：

   • set_cookie() / set_signed_cookie() / delete_cookie() - 添加/删除Cookie
   • __setitem__ / __getitem__ / __delitem__ - 添加/获取/删除响应头
   • charset / content / status_code - 响应的字符集/消息体（bytes流）/状态码
     • 1xx：请求已经收到，继续处理
     • 2xx（成功）：请求已经成功收到、理解和接收。
     • 3xx（重定向）：为完成请求要继续执行后续的操作。
     • 4xx（客户端错误）：请求不正确或不能够被受理。
     • 5xx（服务器错误）：服务器处理请求失败。

4. JsonResponse（HttpResponse的子类型）对象

   1
   >>> from django.http import HttpResponse, JsonResponse
   2
   >>>
   3
   >>> response = JsonResponse({'foo': 'bar'})
   4
   >>> response.content
   5
   >>>
   6
   >>> response = JsonResponse([1, 2, 3], safe=False)
   7
   >>> response.content
   8
   >>>
   9
   >>> response = HttpResponse(b'...')
   10
   >>> response['cotent-type'] = 'application/pdf';
   11
   >>> response['content-disposition'] = 'inline; filename="xyz.pdf"'
   12
   >>> response['content-disposition'] = 'attachment; filename="xyz.pdf"'
   13
   >>>
   14
   >>> response.set_signed_cookie('foo', 'bar', salt='')
   15
   >>> response.status_code = 200