This the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

基础设施

1: Git

1.1: 飞行手册
1.2: 速查手册

2: Docker

2.1: Dockerfile
2.2: Cheat Sheet
2.3: Docker 实战

3: Kubernetes

3.1: 问题排查

4: Maven

4.1: Maven Release

5: 配置中心

6: 调度中心

7: ID 生成服务

Working In Progress

1 - Git

1.1 - 飞行手册

Flight rules for Git: k88hudson/git-flight-rules: Flight rules for git

编辑提交(editting commits)

我刚才提交了什么?

如果你用 git commit -a 提交了一次变化(changes)，而你又不确定到底这次提交了哪些内容。你就可以用下面的命令显示当前HEAD上的最近一次的提交(commit):

(main)$ git show

或者

$ git log -n1 -p

我的提交信息(commit message)写错了

如果你的提交信息(commit message)写错了且这次提交(commit)还没有推(push), 你可以通过下面的方法来修改提交信息(commit message):

$ git commit --amend --only

这会打开你的默认编辑器, 在这里你可以编辑信息. 另一方面, 你也可以用一条命令一次完成:

$ git commit --amend --only -m 'xxxxxxx'

如果你已经推(push)了这次提交(commit), 你可以修改这次提交(commit)然后强推(force push), 但是不推荐这么做。

我提交(commit)里的用户名和邮箱不对

如果这只是单个提交(commit)，修改它：

$ git commit --amend --author "New Authorname <authoremail@mydomain.com>"

如果你需要修改所有历史, 参考 ‘git filter-branch’的指南页.

我想从一个提交(commit)里移除一个文件

通过下面的方法，从一个提交(commit)里移除一个文件:

$ git checkout HEAD^ myfile
$ git add -A
$ git commit --amend

这将非常有用，当你有一个开放的补丁(open patch)，你往上面提交了一个不必要的文件，你需要强推(force push)去更新这个远程补丁。

我想删除我的的最后一次提交(commit)

如果你需要删除推了的提交(pushed commits)，你可以使用下面的方法。可是，这会不可逆的改变你的历史，也会搞乱那些已经从该仓库拉取(pulled)了的人的历史。简而言之，如果你不是很确定，千万不要这么做。

$ git reset HEAD^ --hard
$ git push -f [remote] [branch]

如果你还没有推到远程, 把Git重置(reset)到你最后一次提交前的状态就可以了(同时保存暂存的变化):

(my-branch*)$ git reset --soft HEAD@{1}

这只能在没有推送之前有用. 如果你已经推了, 唯一安全能做的是 git revert SHAofBadCommit，那会创建一个新的提交(commit)用于撤消前一个提交的所有变化(changes)；或者, 如果你推的这个分支是rebase-safe的 (例如：其它开发者不会从这个分支拉), 只需要使用 git push -f；更多, 请参考 the above section。

删除任意提交(commit)

同样的警告：不到万不得已的时候不要这么做.

$ git rebase --onto SHA1_OF_BAD_COMMIT^ SHA1_OF_BAD_COMMIT
$ git push -f [remote] [branch]

或者做一个交互式rebase 删除那些你想要删除的提交(commit)里所对应的行。

我尝试推一个修正后的提交(amended commit)到远程，但是报错：

To https://github.com/yourusername/repo.git
! [rejected]        mybranch -> mybranch (non-fast-forward)
error: failed to push some refs to 'https://github.com/tanay1337/webmaker.org.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

注意, rebasing(见下面)和修正(amending)会用一个新的提交(commit)代替旧的, 所以如果之前你已经往远程仓库上推过一次修正前的提交(commit)，那你现在就必须强推(force push) (-f)。注意 – 总是确保你指明一个分支!

(my-branch)$ git push origin mybranch -f

一般来说, 要避免强推. 最好是创建和推(push)一个新的提交(commit)，而不是强推一个修正后的提交。后者会使那些与该分支或该分支的子分支工作的开发者，在源历史中产生冲突。

我意外的做了一次硬重置(hard reset)，我想找回我的内容

如果你意外的做了 git reset --hard, 你通常能找回你的提交(commit), 因为Git对每件事都会有日志，且都会保存几天。

(main)$ git reflog

你将会看到一个你过去提交(commit)的列表, 和一个重置的提交。选择你想要回到的提交(commit)的SHA，再重置一次:

(main)$ git reset --hard SHA1234

这样就完成了。

暂存(Staging)

我需要把暂存的内容添加到上一次的提交(commit)

(my-branch*)$ git commit --amend

我想要暂存一个新文件的一部分，而不是这个文件的全部

一般来说, 如果你想暂存一个文件的一部分, 你可这样做:

$ git add --patch filename.x

-p 简写。这会打开交互模式，你将能够用 s 选项来分隔提交(commit)；然而, 如果这个文件是新的, 会没有这个选择，添加一个新文件时, 这样做:

$ git add -N filename.x

然后, 你需要用 e 选项来手动选择需要添加的行，执行 git diff --cached 将会显示哪些行暂存了哪些行只是保存在本地了。

我想把在一个文件里的变化(changes)加到两个提交(commit)里

git add 会把整个文件加入到一个提交. git add -p 允许交互式的选择你想要提交的部分.

我想把暂存的内容变成未暂存，把未暂存的内容暂存起来

多数情况下，你应该将所有的内容变为未暂存，然后再选择你想要的内容进行commit。但假定你就是想要这么做，这里你可以创建一个临时的commit来保存你已暂存的内容，然后暂存你的未暂存的内容并进行stash。然后reset最后一个commit将原本暂存的内容变为未暂存，最后stash pop回来。

$ git commit -m "WIP"
$ git add .
$ git stash
$ git reset HEAD^
$ git stash pop --index 0

注意1: 这里使用pop仅仅是因为想尽可能保持幂等。注意2: 假如你不加上--index你会把暂存的文件标记为为存储.这个链接解释得比较清楚。（不过是英文的，其大意是说，这是一个较为底层的问题，stash时会做2个commit，其中一个会记录index状态，staged的文件等东西，另一个记录worktree和其他的一些东西，如果你不在apply时加index，git会把两个一起销毁，所以staged里就空了）。

未暂存(Unstaged)的内容

我想把未暂存的内容移动到一个新分支

$ git checkout -b my-branch

我想把未暂存的内容移动到另一个已存在的分支

$ git stash
$ git checkout my-branch
$ git stash pop

我想丢弃本地未提交的变化(uncommitted changes)

如果你只是想重置源(origin)和你本地(local)之间的一些提交(commit)，你可以：

# one commit
(my-branch)$ git reset --hard HEAD^
# two commits
(my-branch)$ git reset --hard HEAD^^
# four commits
(my-branch)$ git reset --hard HEAD~4
# or
(main)$ git checkout -f

重置某个特殊的文件, 你可以用文件名做为参数:

$ git reset filename

我想丢弃某些未暂存的内容

如果你想丢弃工作拷贝中的一部分内容，而不是全部。

签出(checkout)不需要的内容，保留需要的。

$ git checkout -p
# Answer y to all of the snippets you want to drop

另外一个方法是使用 stash， Stash所有要保留下的内容, 重置工作拷贝, 重新应用保留的部分。

$ git stash -p
# Select all of the snippets you want to save
$ git reset --hard
$ git stash pop

或者, stash 你不需要的部分, 然后stash drop。

$ git stash -p
# Select all of the snippets you don't want to save
$ git stash drop

分支(Branches)

我从错误的分支拉取了内容，或把内容拉取到了错误的分支

这是另外一种使用 git reflog 情况，找到在这次错误拉(pull) 之前HEAD的指向。

(main)$ git reflog
ab7555f HEAD@{0}: pull origin wrong-branch: Fast-forward
c5bc55a HEAD@{1}: checkout: checkout message goes here

重置分支到你所需的提交(desired commit):

$ git reset --hard c5bc55a

完成。

我想扔掉本地的提交(commit)，以便我的分支与远程的保持一致

先确认你没有推(push)你的内容到远程。

git status 会显示你领先(ahead)源(origin)多少个提交:

(my-branch)$ git status
# On branch my-branch
# Your branch is ahead of 'origin/my-branch' by 2 commits.
#   (use "git push" to publish your local commits)
#

一种方法是:

(main)$ git reset --hard origin/my-branch

我需要提交到一个新分支，但错误的提交到了main

在main下创建一个新分支，不切换到新分支,仍在main下:

(main)$ git branch my-branch

把main分支重置到前一个提交:

(main)$ git reset --hard HEAD^

HEAD^ 是 HEAD^1 的简写，你可以通过指定要设置的HEAD来进一步重置。

或者, 如果你不想使用 HEAD^, 找到你想重置到的提交(commit)的hash(git log 能够完成)，然后重置到这个hash。使用git push 同步内容到远程。

例如, main分支想重置到的提交的hash为a13b85e:

(main)$ git reset --hard a13b85e
HEAD is now at a13b85e

签出(checkout)刚才新建的分支继续工作:

(main)$ git checkout my-branch

我想保留来自另外一个ref-ish的整个文件

假设你正在做一个原型方案(原文为working spike (see note)), 有成百的内容，每个都工作得很好。现在, 你提交到了一个分支，保存工作内容:

(solution)$ git add -A && git commit -m "Adding all changes from this spike into one big commit."

当你想要把它放到一个分支里 (可能是feature, 或者 develop), 你关心是保持整个文件的完整，你想要一个大的提交分隔成比较小。

假设你有:

分支 solution, 拥有原型方案，领先 develop 分支。
分支 develop, 在这里你应用原型方案的一些内容。

我去可以通过把内容拿到你的分支里，来解决这个问题:

(develop)$ git checkout solution -- file1.txt

这会把这个文件内容从分支 solution 拿到分支 develop 里来:

# On branch develop
# Your branch is up-to-date with 'origin/develop'.
# Changes to be committed:
#  (use "git reset HEAD <file>..." to unstage)
#
#        modified:   file1.txt

然后, 正常提交。

Note: Spike solutions are made to analyze or solve the problem. These solutions are used for estimation and discarded once everyone gets clear visualization of the problem. ~ Wikipedia.

我把几个提交(commit)提交到了同一个分支，而这些提交应该分布在不同的分支里

假设你有一个main分支，执行git log, 你看到你做过两次提交:

(main)$ git log

commit e3851e817c451cc36f2e6f3049db528415e3c114
Author: Alex Lee <alexlee@example.com>
Date:   Tue Jul 22 15:39:27 2014 -0400

    Bug #21 - Added CSRF protection

commit 5ea51731d150f7ddc4a365437931cd8be3bf3131
Author: Alex Lee <alexlee@example.com>
Date:   Tue Jul 22 15:39:12 2014 -0400

    Bug #14 - Fixed spacing on title

commit a13b85e984171c6e2a1729bb061994525f626d14
Author: Aki Rose <akirose@example.com>
Date:   Tue Jul 21 01:12:48 2014 -0400

    First commit

让我们用提交hash(commit hash)标记bug (e3851e8 for #21, 5ea5173 for #14).

首先, 我们把main分支重置到正确的提交(a13b85e):

(main)$ git reset --hard a13b85e
HEAD is now at a13b85e

现在, 我们对 bug #21 创建一个新的分支:

(main)$ git checkout -b 21
(21)$

接着, 我们用 cherry-pick 把对bug #21的提交放入当前分支。这意味着我们将应用(apply)这个提交(commit)，仅仅这一个提交(commit)，直接在HEAD上面。

(21)$ git cherry-pick e3851e8

这时候, 这里可能会产生冲突，参见交互式 rebasing 章 冲突节 解决冲突.

再者，我们为bug #14 创建一个新的分支, 也基于main分支

(21)$ git checkout main
(main)$ git checkout -b 14
(14)$

最后, 为 bug #14 执行 cherry-pick:

(14)$ git cherry-pick 5ea5173

我想删除上游(upstream)分支被删除了的本地分支

一旦你在github 上面合并(merge)了一个pull request, 你就可以删除你fork里被合并的分支。如果你不准备继续在这个分支里工作, 删除这个分支的本地拷贝会更干净，使你不会陷入工作分支和一堆陈旧分支的混乱之中。

$ git fetch -p

我不小心删除了我的分支

如果你定期推送到远程, 多数情况下应该是安全的，但有些时候还是可能删除了还没有推到远程的分支。让我们先创建一个分支和一个新的文件:

(main)$ git checkout -b my-branch
(my-branch)$ git branch
(my-branch)$ touch foo.txt
(my-branch)$ ls
README.md foo.txt

添加文件并做一次提交

(my-branch)$ git add .
(my-branch)$ git commit -m 'foo.txt added'
(my-branch)$ foo.txt added
 1 files changed, 1 insertions(+)
 create mode 100644 foo.txt
(my-branch)$ git log

commit 4e3cd85a670ced7cc17a2b5d8d3d809ac88d5012
Author: siemiatj <siemiatj@example.com>
Date:   Wed Jul 30 00:34:10 2014 +0200

    foo.txt added

commit 69204cdf0acbab201619d95ad8295928e7f411d5
Author: Kate Hudson <katehudson@example.com>
Date:   Tue Jul 29 13:14:46 2014 -0400

    Fixes #6: Force pushing after amending commits

现在我们切回到主(main)分支，‘不小心的’删除my-branch分支

(my-branch)$ git checkout main
Switched to branch 'main'
Your branch is up-to-date with 'origin/main'.
(main)$ git branch -D my-branch
Deleted branch my-branch (was 4e3cd85).
(main)$ echo oh noes, deleted my branch!
oh noes, deleted my branch!

在这时候你应该想起了reflog, 一个升级版的日志，它存储了仓库(repo)里面所有动作的历史。

(main)$ git reflog
69204cd HEAD@{0}: checkout: moving from my-branch to main
4e3cd85 HEAD@{1}: commit: foo.txt added
69204cd HEAD@{2}: checkout: moving from main to my-branch

正如你所见，我们有一个来自删除分支的提交hash(commit hash)，接下来看看是否能恢复删除了的分支。

(main)$ git checkout -b my-branch-help
Switched to a new branch 'my-branch-help'
(my-branch-help)$ git reset --hard 4e3cd85
HEAD is now at 4e3cd85 foo.txt added
(my-branch-help)$ ls
README.md foo.txt

看! 我们把删除的文件找回来了。 Git的 reflog 在rebasing出错的时候也是同样有用的。

我想删除一个分支

删除一个远程分支:

(main)$ git push origin --delete my-branch

你也可以:

(main)$ git push origin :my-branch

删除一个本地分支:

(main)$ git branch -D my-branch

我想从别人正在工作的远程分支签出(checkout)一个分支

首先, 从远程拉取(fetch) 所有分支:

(main)$ git fetch --all

假设你想要从远程的daves分支签出到本地的daves

(main)$ git checkout --track origin/daves
Branch daves set up to track remote branch daves from origin.
Switched to a new branch 'daves'

(--track 是 git checkout -b [branch] [remotename]/[branch] 的简写)

这样就得到了一个daves分支的本地拷贝, 任何推过(pushed)的更新，远程都能看到.

Rebasing 和合并(Merging)

我想撤销rebase/merge

你可以合并(merge)或rebase了一个错误的分支, 或者完成不了一个进行中的rebase/merge。 Git 在进行危险操作的时候会把原始的HEAD保存在一个叫ORIG_HEAD的变量里, 所以要把分支恢复到rebase/merge前的状态是很容易的。

(my-branch)$ git reset --hard ORIG_HEAD

我已经rebase过, 但是我不想强推(force push)

不幸的是，如果你想把这些变化(changes)反应到远程分支上，你就必须得强推(force push)。是因你快进(Fast forward)了提交，改变了Git历史, 远程分支不会接受变化(changes)，除非强推(force push)。这就是许多人使用 merge 工作流, 而不是 rebasing 工作流的主要原因之一，开发者的强推(force push)会使大的团队陷入麻烦。使用时需要注意，一种安全使用 rebase 的方法是，不要把你的变化(changes)反映到远程分支上, 而是按下面的做:

(main)$ git checkout my-branch
(my-branch)$ git rebase -i main
(my-branch)$ git checkout main
(main)$ git merge --ff-only my-branch

更多, 参见 this SO thread.

我需要组合(combine)几个提交(commit)

假设你的工作分支将会做对于 main 的pull-request。一般情况下你不关心提交(commit)的时间戳，只想组合所有提交(commit) 到一个单独的里面, 然后重置(reset)重提交(recommit)。确保主(main)分支是最新的和你的变化都已经提交了, 然后:

(my-branch)$ git reset --soft main
(my-branch)$ git commit -am "New awesome feature"

如果你想要更多的控制, 想要保留时间戳, 你需要做交互式rebase (interactive rebase):

(my-branch)$ git rebase -i main

如果没有相对的其它分支，你将不得不相对自己的HEAD 进行 rebase。例如：你想组合最近的两次提交(commit), 你将相对于HEAD~2 进行rebase，组合最近3次提交(commit), 相对于HEAD~3, 等等。

(main)$ git rebase -i HEAD~2

在你执行了交互式 rebase的命令(interactive rebase command)后, 你将在你的编辑器里看到类似下面的内容:

pick a9c8a1d Some refactoring
pick 01b2fd8 New awesome feature
pick b729ad5 fixup
pick e3851e8 another fix

# Rebase 8074d12..b729ad5 onto 8074d12
#
# Commands:
#  p, pick = use commit
#  r, reword = use commit, but edit the commit message
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#  f, fixup = like "squash", but discard this commit's log message
#  x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

所有以 # 开头的行都是注释, 不会影响 rebase.

然后，你可以用任何上面命令列表的命令替换 pick, 你也可以通过删除对应的行来删除一个提交(commit)。

例如, 如果你想 单独保留最旧(first)的提交(commit),组合所有剩下的到第二个里面, 你就应该编辑第二个提交(commit)后面的每个提交(commit) 前的单词为 f:

pick a9c8a1d Some refactoring
pick 01b2fd8 New awesome feature
f b729ad5 fixup
f e3851e8 another fix

如果你想组合这些提交(commit) 并重命名这个提交(commit), 你应该在第二个提交(commit)旁边添加一个r，或者更简单的用s 替代 f:

pick a9c8a1d Some refactoring
pick 01b2fd8 New awesome feature
s b729ad5 fixup
s e3851e8 another fix

你可以在接下来弹出的文本提示框里重命名提交(commit)。

Newer, awesomer features

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
# rebase in progress; onto 8074d12
# You are currently editing a commit while rebasing branch 'main' on '8074d12'.
#
# Changes to be committed:
#	modified:   README.md
#

如果成功了, 你应该看到类似下面的内容:

(main)$ Successfully rebased and updated refs/heads/main.

安全合并(merging)策略

--no-commit 执行合并(merge)但不自动提交, 给用户在做提交前检查和修改的机会。 no-ff 会为特性分支(feature branch)的存在过留下证据, 保持项目历史一致。

(main)$ git merge --no-ff --no-commit my-branch

我需要将一个分支合并成一个提交(commit)

(main)$ git merge --squash my-branch

我只想组合(combine)未推的提交(unpushed commit)

有时候，在将数据推向上游之前，你有几个正在进行的工作提交(commit)。这时候不希望把已经推(push)过的组合进来，因为其他人可能已经有提交(commit)引用它们了。

(main)$ git rebase -i @{u}

这会产生一次交互式的rebase(interactive rebase), 只会列出没有推(push)的提交(commit)，在这个列表时进行reorder/fix/squash 都是安全的。

检查是否分支上的所有提交(commit)都合并(merge)过了

检查一个分支上的所有提交(commit)是否都已经合并(merge)到了其它分支, 你应该在这些分支的head(或任何 commits)之间做一次diff:

(main)$ git log --graph --left-right --cherry-pick --oneline HEAD...feature/120-on-scroll

这会告诉你在一个分支里有而另一个分支没有的所有提交(commit), 和分支之间不共享的提交(commit)的列表。另一个做法可以是:

(main)$ git log main ^feature/120-on-scroll --no-merges

交互式rebase(interactive rebase)可能出现的问题

这个rebase 编辑屏幕出现’noop’

如果你看到的是这样:

noop

这意味着你rebase的分支和当前分支在同一个提交(commit)上, 或者 领先(ahead) 当前分支。你可以尝试:

检查确保主(main)分支没有问题
rebase HEAD~2 或者更早

有冲突的情况

如果你不能成功的完成rebase, 你可能必须要解决冲突。

首先执行 git status 找出哪些文件有冲突:

(my-branch)$ git status
On branch my-branch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

	modified:   README.md

在这个例子里面, README.md 有冲突。打开这个文件找到类似下面的内容:

   <<<<<<< HEAD
   some code
   =========
   some code
   >>>>>>> new-commit

你需要解决新提交的代码(示例里, 从中间==线到new-commit的地方)与HEAD 之间不一样的地方.

有时候这些合并非常复杂，你应该使用可视化的差异编辑器(visual diff editor):

(main*)$ git mergetool -t opendiff

在你解决完所有冲突和测试过后, git add 变化了的(changed)文件, 然后用git rebase --continue 继续rebase。

(my-branch)$ git add README.md
(my-branch)$ git rebase --continue

如果在解决完所有的冲突过后，得到了与提交前一样的结果, 可以执行git rebase --skip。

任何时候你想结束整个rebase 过程，回来rebase前的分支状态, 你可以做:

(my-branch)$ git rebase --abort

Stash

暂存所有改动

暂存你工作目录下的所有改动

$ git stash

你可以使用-u来排除一些文件

$ git stash -u

暂存指定文件

假设你只想暂存某一个文件

$ git stash push working-directory-path/filename.ext

假设你想暂存多个文件

$ git stash push working-directory-path/filename1.ext working-directory-path/filename2.ext

暂存时记录消息

这样你可以在list时看到它

$ git stash save <message>

或

$ git stash push -m <message>

使用某个指定暂存

首先你可以查看你的stash记录

$ git stash list

然后你可以apply某个stash

$ git stash apply "stash@{n}"

此处， ’n’是stash在栈中的位置，最上层的stash会是0

除此之外，也可以使用时间标记(假如你能记得的话)。

$ git stash apply "stash@{2.hours.ago}"

暂存时保留未暂存的内容

你需要手动create一个stash commit，然后使用git stash store。

$ git stash create
$ git stash store -m "commit-message" CREATED_SHA1

杂项(Miscellaneous Objects)

克隆所有子模块

$ git clone --recursive git://github.com/foo/bar.git

如果已经克隆了:

$ git submodule update --init --recursive

删除标签(tag)

$ git tag -d <tag_name>
$ git push <remote> :refs/tags/<tag_name>

恢复已删除标签(tag)

如果你想恢复一个已删除标签(tag), 可以按照下面的步骤: 首先, 需要找到无法访问的标签(unreachable tag):

$ git fsck --unreachable | grep tag

记下这个标签(tag)的hash，然后用Git的 update-ref:

$ git update-ref refs/tags/<tag_name> <hash>

这时你的标签(tag)应该已经恢复了。

已删除补丁(patch)

如果某人在 GitHub 上给你发了一个pull request, 但是然后他删除了他自己的原始 fork, 你将没法克隆他们的提交(commit)或使用 git am。在这种情况下, 最好手动的查看他们的提交(commit)，并把它们拷贝到一个本地新分支，然后做提交。

做完提交后, 再修改作者，参见变更作者。然后, 应用变化, 再发起一个新的pull request。

跟踪文件(Tracking Files)

我只想改变一个文件名字的大小写，而不修改内容

(main)$ git mv --force myfile MyFile

我想从Git删除一个文件，但保留该文件

(main)$ git rm --cached log.txt

配置(Configuration)

我想给一些Git命令添加别名(alias)

在 OS X 和 Linux 下, 你的 Git的配置文件储存在 ~/.gitconfig。我在[alias] 部分添加了一些快捷别名(和一些我容易拼写错误的)，如下:

[alias]
    a = add
    amend = commit --amend
    c = commit
    ca = commit --amend
    ci = commit -a
    co = checkout
    d = diff
    dc = diff --changed
    ds = diff --staged
    f = fetch
    loll = log --graph --decorate --pretty=oneline --abbrev-commit
    m = merge
    one = log --pretty=oneline
    outstanding = rebase -i @{u}
    s = status
    unpushed = log @{u}
    wc = whatchanged
    wip = rebase -i @{u}
    zap = fetch -p

我想缓存一个仓库(repository)的用户名和密码

你可能有一个仓库需要授权，这时你可以缓存用户名和密码，而不用每次推/拉(push/pull)的时候都输入，Credential helper能帮你。

$ git config --global credential.helper cache
# Set git to use the credential memory cache

$ git config --global credential.helper 'cache --timeout=3600'
# Set the cache to timeout after 1 hour (setting is in seconds)

我不知道我做错了些什么

你把事情搞砸了：你 重置(reset) 了一些东西, 或者你合并了错误的分支, 亦或你强推了后找不到你自己的提交(commit)了。有些时候, 你一直都做得很好, 但你想回到以前的某个状态。

这就是 git reflog 的目的， reflog 记录对分支顶端(the tip of a branch)的任何改变, 即使那个顶端没有被任何分支或标签引用。基本上, 每次HEAD的改变, 一条新的记录就会增加到reflog。遗憾的是，这只对本地分支起作用，且它只跟踪动作 (例如，不会跟踪一个没有被记录的文件的任何改变)。

(main)$ git reflog
0a2e358 HEAD@{0}: reset: moving to HEAD~2
0254ea7 HEAD@{1}: checkout: moving from 2.2 to main
c10f740 HEAD@{2}: checkout: moving from main to 2.2

上面的reflog展示了从main分支签出(checkout)到2.2 分支，然后再签回。那里，还有一个硬重置(hard reset)到一个较旧的提交。最新的动作出现在最上面以 HEAD@{0}标识.

如果事实证明你不小心回移(move back)了提交(commit), reflog 会包含你不小心回移前main上指向的提交(0254ea7)。

$ git reset --hard 0254ea7

然后使用git reset就可以把main改回到之前的commit，这提供了一个在历史被意外更改情况下的安全网。

(摘自).

中文被转义为 Unicode 码

如果文件路径或文件名包含中文，会被转移为 Unicode 码，这时需要设置：

$ git config --global core.quotepath false

其它资源(Other Resources)

书(Books)

Pro Git - Scott Chacon’s excellent git book
Git Internals - Scott Chacon’s other excellent git book

教程(Tutorials)

Learn Git branching 一个基于网页的交互式 branching/merging/rebasing 教程
Getting solid at Git rebase vs. merge
git-workflow - Aaron Meurer的怎么使用Git为开源仓库贡献
GitHub as a workflow - 使用GitHub做为工作流的趣事, 尤其是空PRs

脚本和工具(Scripts and Tools)

firstaidgit.io 一个可搜索的最常被问到的Git的问题
git-extra-commands - 一堆有用的额外的Git脚本
git-extras - GIT 工具集 – repo summary, repl, changelog population, author commit percentages and more
git-fire - git-fire 是一个 Git 插件，用于帮助在紧急情况下添加所有当前文件, 做提交(committing), 和推(push)到一个新分支(阻止合并冲突)。
git-tips - Git小提示
git-town - 通用，高级Git工作流支持！ http://www.git-town.com

GUI客户端(GUI Clients)

GitKraken - 豪华的Git客户端 Windows, Mac & Linux
git-cola - 另外一个Git客户端 Windows & OS X
GitUp - 一个新的Git客户端，在处理Git的复杂性上有自己的特点
gitx-dev - 图形化的Git客户端 OS X
Source Tree - 免费的图形化Git客户端 Windows & OS X
Tower - 图形化Git客户端 OS X(付费)

1.2 - 速查手册

2 - Docker

2.1 - Dockerfile

Dockerfile

Docker可以通过Dockerfile自动构建镜像，Dockerfile是一个包含多个指令的文档。如下

# syntax=docker/dockerfile:1
FROM ubuntu:18.04
COPY . /app
RUN make /app
CMD python /app/app.py

FROM

FROM命令用于初始化一个新的构建阶段，并为后续指令设置基础镜像：

FROM [--platform=<platform>] <image> [AS <name>]
FROM [--platform=<platform>] <image>[:<tag>] [AS <name>]
FROM [--platform=<platform>] <image>[@<digest>] [AS <name>]

FROM指令用于指定基础镜像，ARG是唯一可以位于FROM指令之前的指令，一般用于声明基础镜像的版本。
单个Dockerfile可以多次出现FROM，以使用之前的构建阶段作为另一个构建阶段的依赖项。
--platform选项可用在FROM多平台镜像的情况下指定平台。例如，linux/amd64、lunux/arm64、windows/amd64。
AS name表示为构建阶段命令，在后续FROM和COPY --from=name说明中可以使用这个名词，引用此阶段构建的映像。
tag或digest值是可选的。如果您省略其中任何一个，构建器默认使用latest标签。如果找不到指定tag，构建起将返回错误。

ARG CODE_VERSION=latest
FROM base:${CODE_VERSION}
CMD /code/run-app
FROM extras:${CODE_VERSION}
CMD /code/run-extras

RUN

RUN指令将在当前镜像之上的新层中执行命令，并且提交结果。在docker build时运行。

RUN /bin/bash -c 'source $HOME/.bashrc; \
echo $HOME'

RUN有两种形式：

RUN ：shell形式，命令在shell中运行，默认在Linux上使用/bin/sh -c，在Windows上使用cmd /S /C。
RUN [“程序名”,“param1”,“param1”]：exec形式，不会触发shell，所以$HOME这样的环境变量无法使用，但它可以在没有bash的镜像中执行。

说明：

可以使用反斜杠（\）将单个RUN命令延续到下一行。
RUN在下一次构建期间，指令缓存不会自动失效。可以使用--no-cache选项使指令缓存失效。如RUN apt-get update之类的构建缓存将在下一次构建期间被重用，此时构建中可能安装过时版本的工具，但我们可以使用–no-cache标志来使RUN命令的缓存失效，如docker build –no-cache。
Dockerfile的指令每执行一次就会给镜像新建一层只读层。过多无意义的层会造成镜像膨胀过大，可以使用&&符号连接多个命令，这样执行RUN指令后之后创建一层镜像。

有些命令会使用管道（|），如：

RUN wget -O - https://some.site | wc -l > /number

Docker使用/bin/sh -c解释器，解释器只计算所有一个命令的退出状态码以确定命令是否执行成功，如上例，只要wc -l执行成功，即使wget命令失败，这个构建步骤也会生成一层新镜像。如果希望命令由于管道中任意阶段命令的错误而失败，需要预先设置set-o pipefail&&，如下：

 RUN set -o pipefail && wget -O - https://some.site | wc -l > /number

注意，基于debian的镜像要使用exec形式支持-o pipefail:
RUN ["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]

CMD

Dockerfile使用RUN指令完成docker build所有的环境安装与配置，通过CMD指令来指示docker run命令运行镜像时要执行的命令。Dockerfile只允许使用一次CMD命令。使用多个CMD会抵消之前所有的命令，只有最后一个命令生效。一般来说，这是整个Dockerfile脚本的最后一个命令。

FROM ubuntu
CMD ["/usr/bin/wc","--help"]

CMD有三种形式：

CMD [“exec”,“param1”,“param2”]：使用exec执行，推荐方式。
CMD command param1 param2：在/bin/sh中执行，可以提供交互操作。
CMD [“param1”,“param2”]：提供给ENTRYPOINT的默认参数（极少这样使用）。

EXPOSE

EXPOSE指令通知容器在运行时监听某个端口，可以指定TCP或UDP，如果不指定协议，默认为TCP端口。但是为了安全，docker run命令如果没有带上相应的端口映射参数，Docker并不会将端口映射出去。

EXPOSE 80/tcp
EXPOSE 80/udp

指定映射端口方式：

docker run -P：将所有端口发布到主机接口，每个公开端口绑定到主机上的随机端口，端口范围在/proc/sys/net/ipv4/ip_local_port_range定义的临时端口范围内。

docker run -p ：显式映射单个端口或端口范围。

LABEL

LABEL指令为镜像添加标签，当前镜像会继承父镜像的标签，如果与父标签重复，会覆盖之前的标签。

LABEL multi.label1="value1" \
  multi.label2="value2" \
  other="value3"
# 或
LABEL multi.label1="value1" multi.label2="value2" other="value3"

可以使用如下方式查看镜像标签：

docker image inspect --format='' myimage

查看结果实例：

{
 "com.example.vendor": "ACME Incorporated",
 "com.example.label-with-value": "foo",
 "version": "1.0",
 "description": "This text illustrates that label-values can span multiple lines.",
 "multi.label1": "value1",
 "multi.label2": "value2",
 "other": "value3"
}

ENV

ENV命令用来在执行docker run命令运行镜像时指定自动设置的环境变量。这个环境变量可以在后续任何RUN命令中使用，并在容器运行时保持。一般用于软件更便捷的运行，如：

ENV PATH=/usr/local/nginx/bin:$PATH
CMD ["nginx"]

设置的环境变量将持续存在，可以使用docker inspect来查看。这些环境变量可以通过docker run --env <key>=<value>命令的参数来修改。

ARG

ARG命令定义用户只在构建时使用的变量，效果和docker build --build-arg <varname>=<value>一样，这个参数只会在构建时存在，不会保留在镜像中。

ARG <name>[=<default value>]

ARG与ENV类似，不同的是ENV会在镜像构建结束后一直保存在容器中，而ARG会在镜像构建结束狗消失。一般运用在希望整个构建过程是无交互的，那么可以使用ARG命令（仅限Debian发行版）。

ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y ...

Docker 有一组预定义的 ARG 变量，您可以在 Dockerfile 中没有相应指令的情况下使用这些变量。

HTTP_PROXY
http_proxy
HTTPS_PROXY
https_proxy
FTP_PROXY
ftp_proxy
NO_PROXY
no_proxy

要使用这些，请使用 –build-arg 标志在命令行上传递它们，例如：

docker build --build-arg HTTPS_PROXY=https://my-proxy.example.com .

ADD

ADD指令用于复制新文件、目录或远程文件 URL到容器路径中。可以指定多个资源，但如果它们是文件或目录，则它们的路径被解释为相对于构建上下文的源，也就是 WORKDIR。

ADD指令有两种形式：

ADD [--chown=<user>:<group>] <src>... <dest>
ADD [--chown=<user>:<group>] ["<src>",... "<dest>"]

每个都可能包含通配符，匹配将使用 Go 的 filepath.Match 规则。是一个绝对路径，或相对 WORKDIR 的相对路径。例如：

添加所有以“hom”开头的文件：

ADD hom* /mydir/

在下面的示例中，? 被替换为任何单个字符，例如“home.txt”。

ADD hom?.txt /mydir/

所有新创建的文件和目录的UID和GID都为0，除非使用--chown指定UID/GID以及权限。-chown特性仅在用于构建Linux容器。

ADD --chown=55:mygroup files* /somedir/
ADD --chown=bin files* /somedir/
ADD --chown=1 files* /somedir/
ADD --chown=10:11 files* /somedir/

如果是一个可识别压缩格式（identity、gzip、bzip2或xz）的本地tar存档，那么它将被解包为一个目录。远程URL中的资源不会解压缩。当一个目录被复制或解包时，它的行为与tar -x相同。

COPY

COPY 指令和 ADD 指令的唯一区别在于：是否支持从远程URL获取资源。COPY 指令只能从执行 docker build 所在的主机上读取资源并复制到镜像中。而 ADD 指令还支持通过 URL 从远程服务器读取资源并复制到镜像中。

相同复制命令下，使用ADD构建的镜像比COPY命令构建的体积大，所以如果只是复制文件使用COPY命令。ADD 指令更擅长读取本地tar文件并解压缩。

ENTRYPOINT

ENTRYPOINT和CMD一样，都是在指定容器启动程序以及参数，不会它不会被docker run的命令行指令所覆盖。如果要覆盖的话需要通过docker run --entrypoint来指定。

ENTRYPOINT有两种形式：

ENTRYPOINT ["exec","param1","param1"]
ENTRYPOINT command param1 param2

指定了ENTRYPOINT后，CMD的内容作为参数传递给ENTRYPOINT指令，实际执行时将变为：

<ENTRYPOINT><CMD>

VOLUME

创建一个具有指定名称的挂载数据卷。

VOLUME ["/var/log/"]
VOLUME /var/log

VOLUME的主要作用是：

避免重要的数据因容器重启而丢失。
避免容器不断变大。
保留配置文件。

ONBUILD

ONBUILD指令作为触发指令添加到镜像中，只有在该镜像作为基础镜像时执行。触发器将在下游构建的Dockerfile中的FROM指令之后执行。如果任何触发器失败，FROM指令将中止，从而导致生成失败。如果所有触发器都成功，FROM指令将完成，构建将照常继续。

ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src

注意，ONBUILD指令不能触发FORM和MAINTAINER指令。

STOPSIGNAL

设置容器退出时唤起的系统调用信号。该信号可以是与内核系统调用表中的位置匹配的有效无符号数字，例如9，或格式为SIGNAME的信号名称，如SIGKILL。

STOPSIGNAL signal

默认的stop-signal是SIGTERM，在docker stop的时候会给容器内PID为1的进程发送这个信号，通过--stop-signal可以设置需要的signal，主要用于让容器内的程序在接收到signal之后可以先处理些未完成的事务，实现优雅结束进程后退出容器。如果不做任何处理，容器将在一段时间后强制退出，可能会造成业务强制中断，默认时间是10s。

HEALTHCHECK

HEALTHCHECK指令告诉容器如何检查它是否保持运行。当容器具有指定的HEALTHCHECK时，除了其正常状态外，还具有健康状态。容器的状态最初是starting，只要通过健康检查，容器的状态就变成healthy（无论之前处于什么状态）。如果经过一定数量的失败检查，容器的状态会变成unhealthy。

该HEALTHCHECK指令有两种形式：

HEALTHCHECK [OPTIONS] CMD command：通过容器内运行命令来检查容器健康状况。后面命令的退出状态会影响容器的健康状态，如：
- 0: success - 容器是健康的，并且准备使用
- 1: unhealthy - 容器没有正确工作
- 2: reserved - 没有使用退出状态
HEALTHCHECK NONE：禁用从基础镜像继承的任何健康检查。

HEALTHCHECK选项（应处于CMD之前）：

--interval=DURATION：检查间隔，default: 30s。
--timeout=DURATION：检查超时时间，超出此范围认为检查失败，default: 30s。
--start-period=DURATION：容器初始化阶段的时间，此阶段健康检查失败不计入最大重试次数，如果检查成功则认为容器已启动，default: 0s。
--retries=N：健康检查连续失败次数，default: 3。

举例：

HEALTHCHECK --interval=5m --timeout=3s \
 CMD curl -f http://localhost/ || exit 1

SHELL

SHELL指令用于设置默认shell。Linux上默认shell是["/bin/sh","-c"]，Windows上是["cmd","/S","/C"]。

SHELL ["exec","param1"]

SHELL指令在Windows上特别有用，因为Windows有两种截然不同的本机SHELL：CMD和powershell，以及备用的sh。该SHELL指令可以出现多次。每条SHELL指令都会覆盖所有先前的SHELL指令，并影响后续指令。

FROM
Learn more about the "FROM" Dockerfile command.
 microsoft/windowsservercore

# Executed as cmd /S /C echo default
RUN echo default

# Executed as cmd /S /C powershell -command Write-Host default
RUN powershell -command Write-Host default

# Executed as powershell -command Write-Host hello
SHELL ["powershell", "-command"]
RUN Write-Host hello

# Executed as cmd /S /C echo hello
SHELL ["cmd", "/S", "/C"]
RUN echo hello

WORKDIR

WORKDIR指令为Dockerfile中接下来的RUN、CMD、ENTRYPOINT、ADD、COPY指令设置工作目录。如果WORKDIR不存在，及时它没有在后续Dockerfile指令中使用，它也会被创建。

Dockerfile中可以多次使用WORKDIR，如果提供了相对路径，它将相对于前一条WORKDIR指令的路径。

WORKDIR /a
WORKDIR b
WORKDIR c
RUN pwd

最终 pwd 命令的输出是 /a/b/c。

该 WORKDIR 指令可以解析先前使用 ENV，例如：

ENV DIRPATH=/path
WORKDIR $DIRPATH/$DIRNAME
RUN pwd

最终 pwd 命令的输出是 /path/$DIRNAME。

官方推荐WORKDIR始终使用绝对路径。此外，尽量避免使用RUN cd ..&& dosomething，大量的类似指令会降低可读性，令Dockerfile难以维护。

USER

RUN指令设置用户名或（UID）和可选用户组（或GID），用于运行Dockerfile中接下来的RUN、CMD、ENTRYPOINT指令。

USER <user>[:<group>]
USER <UID>[:<GID>]

注意，在Linux上，当用户没有主组时，镜像（或指令）将与根组一起运行。在Windows上，如果用户不是内置帐户，则必须首先创建该用户。也可以先通通过net user创建用户，再指定用户。
FROM microsoft/windowsservercore
# Create Windows user in the container
RUN net user /add patrick
# Set it for subsequent commands
USER patrick

MAINTAINER

MAINTAINER指令设置生成镜像的作者。如：

MAINTAINER <name>

2.2 - Cheat Sheet

https://github.com/wsargent/docker-cheat-sheet/tree/master/zh-cn

2.3 - Docker 实战

https://yeasy.gitbook.io/docker_practice/

3 - Kubernetes

3.1 - 问题排查

4 - Maven

4.1 - Maven Release

1. 设置 OSSRH

1.1 创建账户

1.2 证明域名所有权

Now that you have an account the next step in the process is to prove ownership of the domain that matches the group that you’d like to publish to. Usually this is your domain name in reverse, so something like com.company if your domain is company.com. Since our developer community is at solace.community this meant we would publish to the community.solace group.

To prove that we own this domain I had to execute a few simple steps:

Open a New Project Ticket with OSSRH.
Follow the instructions request in the ticket to addd a DNS TXT record to our domain.
Wait a few hours (it says it could take up to 2 business days) for the DNS TXT record to be verified.
Check the ticket for confirmation that domain ownership has been confirmed.
Make a note to comment on this ticket after your first release to enable syncing to maven central!

1.3 创建 Token

Now that we have permission to publish to our domain we need to create a user token for publishing. This token will be used as part of the publishing process.

To get this token do the following:

Login to the OSSRH Nexus Repository Manager w/ your OSSRH account
Go to your profile using the menu under your username at the top right.
You should see a list menu that is on the Summary page; change it to User Token. You can create your token on this page.
Copy & Paste this token info so you can use it later! (Keep it private!)

2. 设置 Maven

Ensured that my groupId starts with the reverse domain that we have approval to publish to! For example this is what we used, note that the groupId starts with community.solace.
When publishing maven projects you have releases and you have snapshots. A “release” is the final build for a version which does not change whereas a “snapshot” is a temporary build which can be replaced by another build with the same name.
Include a description name, description and url pointing to your repository. For example,
Include a license, source control info scm, developers and organization(I believe this is optional) information.
Add a profile for OSSRH which includes the snapshotRepository info, the nexus-staging-maven-plugin, and the maven-gpg-plugin. Note in the example below I have this profile activeByDefault so you don’t have to specify it when running maven commands, however you may not want to do this.
Include the maven-release-plugin, the maven-javadoc-plugin, the maven-source-plugin and the flatten-maven-plugin plugin.

3. 设置 GPG 签名

3.1 创建私有 Key

Install the gpg tool; on mac you can do this by executing the command below. If you aren’t using a mac check out the instructions here
```
brew install gpg
```
Generate your key pair. You will be prompted for a “Real Name” and “Eamil Address” that you want to use with the key
```
gpg --gen-key
```

3.2 共享公共 Key

Get your keypair identifier. To do this you need to list your keys. The key will have an identifier that looks like a random string of characters, something like C48B6G0D63B854H7943892DF0C753FEC18D3F855. In the command below I’ve replaced it with MYIDENTIFIER to show it’s location.

MJD-MacBook-Pro.local:~$ gpg --list-keys
/path/to/keyring/pubring.kbx
----------------------------------------
pub   rsa3072 2021-03-11 [SC] [expires: 2023-03-11]
   MYIDENTIFIER
uid           [ultimate] solacecommunity <community-github@solace.com>
sub   rsa3072 2021-03-11 [E] [expires: 2023-03-11]

Distribute to a key server using the identifier found in the previous step. Note that you may want to publish to a different keyserver. The one that worked for me was hkp://keyserver.ubuntu.com:11371
```
gpg --keyserver hkp://pool.sks-keyservers.net --send-keys MYIDENTIFIER
```

4. 设置 Github 密匙

基于前面的操作，在 Github 中设置以下密匙，可以以仓库或组织来设置：

OSSRH_USERNAME：OSSRH 的登录账户名
OSSRH_PASSWORD：OSSRH 中获得的 Token
OSSRH_GPG_SECRET_KEY：GPG 的私有 Key，可以通过如下命令导出
```
gpg --export-secret-keys -a {KEY-ID} > secret.txt
```
OSSRH_GPG_SECRET_KEY_PASSWORD：GPG 私有 Key 的密码，即创建 Key 时设置的密码

5. 设置 Github Action

参考仓库：infilos/maven-github-action-demo

在该仓库中，推送 main 分支会自动触发 Maven 发布，并创建对应的 Release 日志。