Docker學習筆記，從原理到實踐

什麼是docker

Docker是使用go語言基於LINUX內核的cgroup，namespace以及AUFS 類的 Union FS 等技術，對進程進行封裝隔離的一種操做系統層面的虛擬化技術，因爲隔離的進程獨立於宿主和其它的隔離的進程，所以也稱其爲容器。

Docker和傳統虛擬化技術的對比

爲何要使用 Docker

更高效的利用系統資源

因爲Docker工做在進程級別，不須要進行硬件虛擬以及運行完整操做系統等額外開銷，因此Docker對系統資源的利用率更高。相比虛擬機技術，一個相同配置的主機，每每能夠運行更多數量的應用。

更快速的啓動時間

傳統的虛擬機技術啓動應用服務每每須要數分鐘，而 Docker容器應用，因爲直接運行於宿主內核，無需啓動完整的操做系統，所以能夠作到秒級、甚至毫秒級的啓動時間。大大的節約了開發、測試、部署的時間。

一致的運行環境

因爲開發環境、測試環境、生產環境不一致，致使有些 bug 並未在開發過程當中被發現。Docker 的鏡像提供了除內核外完整的運行時環境，確保了應用運行環境一致性，從而不會再出現 「這段代碼在我機器上沒問題啊」 這類問題。

持續交付和部署

一次建立，屢次運行。經過定製應用鏡像來實現持續集成、持續交付、部署。開發人員能夠經過 Dockerfile 來進行鏡像構建，並結合持續集成(Continuous Integration)系統進行集成測試，而運維人員則能夠直接在生產環境中快速部署該鏡像，甚至結合 持續部署(Continuous Delivery/Deployment) 系統進行自動部署。並且使用 Dockerfile 使鏡像構建透明化，不只僅開發團隊能夠理解應用運行環境，也方便運維團隊理解應用運行所需條件，幫助更好的生產環境中部署該鏡像。

更輕鬆的遷移

Docker 確保了執行環境的一致性，不管是物理機、虛擬機、公有云、私有云，甚至是筆記本，其運行結果是一致的。所以能夠很輕易遷移到任意上，而不用擔憂運行環境的變化致使應用沒法正常運行的狀況。

更輕鬆的維護和擴展

Docker 使用的分層存儲以及鏡像的技術，Docker 團隊同各個開源項目團隊一塊兒維護了一大批高質量的官方鏡像，既能夠直接在生產環境使用，又能夠做爲基礎進一步定製。

對比傳統虛擬機總結

特性	容器	虛擬機
啓動	秒級	分鐘級
硬盤使用	通常爲 MB	通常爲 GB
性能	接近原生	弱於
系統支持量	單機支持上千個容器	通常幾十個

Docker的基本概念

Docker 鏡像

咱們都知道，操做系統分爲內核和用戶空間。對於 Linux 而言，內核啓動後，會掛載根文件系統爲其提供用戶空間支持。而 Docker 鏡像（Image），就至關因而一個根文件系統。

Docker 鏡像是一個特殊的文件系統，除了提供容器運行時所需的程序、庫、資源、配置等文件外，還包含了一些爲運行時準備的一些配置參數（如匿名卷、環境變量、用戶等）。鏡像不包含任何動態數據，其內容在構建以後也不會被改變。

分層存儲

由於鏡像包含操做系統完整的根文件系統，其體積每每是龐大的，所以在 Docker 設計時，就充分利用 Union FS 的技術，將其設計爲分層存儲的架構。因此嚴格來講，鏡像並不是是像一個 ISO 那樣的打包文件，鏡像只是一個虛擬的概念，其實際體現並不是由一個文件組成，而是由一組文件系統組成，或者說，由多層文件系統聯合組成。

鏡像構建時，會一層層構建，前一層是後一層的基礎。每一層構建完就不會再發生改變，後一層上的任何改變只發生在本身這一層。好比，刪除前一層文件的操做，實際不是真的刪除前一層的文件，而是僅在當前層標記爲該文件已刪除。在最終容器運行的時候，雖然不會看到這個文件，可是實際上該文件會一直跟隨鏡像。所以，在構建鏡像的時候，須要額外當心，每一層儘可能只包含該層須要添加的東西，任何額外的東西應該在該層構建結束前清理掉。

分層存儲的特徵還使得鏡像的複用、定製變的更爲容易。甚至能夠用以前構建好的鏡像做爲基礎層，而後進一步添加新的層，以定製本身所需的內容，構建新的鏡像。

Docker 容器

鏡像（Image）和容器（Container）的關係，就像是面向對象程序設計中的類和實例同樣，鏡像是靜態的定義，容器是鏡像運行時的實體。容器能夠被建立、啓動、中止、刪除、暫停等。

容器的實質是進程，但與直接在宿主執行的進程不一樣，容器進程運行於屬於本身的獨立的命名空間。所以容器能夠擁有本身的根文件系統、本身的網絡配置、本身的進程空間，甚至本身的用戶 ID 空間。容器內的進程是運行在一個隔離的環境裏，使用起來，就好像是在一個獨立於宿主的系統下操做同樣。這種特性使得容器封裝的應用比直接在宿主運行更加安全。

前面講過鏡像使用的是分層存儲，容器也是如此。每個容器運行時，是以鏡像爲基礎層，在其上建立一個當前容器的存儲層，咱們能夠稱這個爲容器運行時讀寫而準備的存儲層爲容器存儲層。

容器存儲層的生存週期和容器同樣，容器消亡時，容器存儲層也隨之消亡。所以，任何保存於容器存儲層的信息都會隨容器刪除而丟失。

按照 Docker 最佳實踐的要求，容器不該該向其存儲層內寫入任何數據，容器存儲層要保持無狀態化。全部的文件寫入操做，都應該使用 數據卷（Volume）、或者綁定宿主目錄，在這些位置的讀寫會跳過容器存儲層，直接對宿主(或網絡存儲)發生讀寫，其性能和穩定性更高。

數據卷的生存週期獨立於容器，容器消亡，數據卷不會消亡。所以，使用數據卷後，容器能夠隨意刪除、從新運行，數據卻不會丟失。

Docker Registry

Docker Registry 提供了鏡像的集中的存儲、分發功能。一個 Docker Registry 中能夠包含多個倉庫（Repository）；每一個倉庫能夠包含多個標籤（Tag）；經過 <倉庫名>:<標籤> 的格式來指定具體是這個軟件哪一個版本的鏡像。Docker Registry 分爲公有服務和私有服務，咱們能夠搭建一個基於本地的registry

Docker 實踐

安裝docker

添加內核參數

tee -a /etc/sysctl.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl -p

添加 yum 源，使用最新版的 docker

tee /etc/yum.repos.d/docker.repo <<-'EOF'
[dockerrepo]
name=Docker Repository
baseurl=https://mirrors.tuna.tsinghua.edu.cn/docker/yum/repo/centos7/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.tuna.tsinghua.edu.cn/docker/yum/gpg
EOF

安裝 docker-engine

yum -y install  docker-engine

啓動docker

systemctl enable docker
systemctl start docker

配置鏡像加速

因爲國內訪問docker原站點很是困難，國內的雲服務提供商提供了加速功能。咱們使用阿里雲進行docker加速
地址： https://dev.aliyun.com/search.html
添加你的專屬地址

sed -i "s|ExecStart=/usr/bin/dockerd|ExecStart=/usr/bin/dockerd --registry-mirror=https://fz5yth0r.mirror.aliyuncs.com|g" /usr/lib/systemd/system/docker.service
systemctl daemon-reload
systemctl restart docker

查看是否加速

docker info

docker info的Registry Mirrors:裏面是否有內容

ps aux|grep dockerd

查看是否有--registry-mirror=

使用鏡像

獲取鏡像

命令格式爲：

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

獲取centos鏡像

docker pull centos

列出鏡像

[root@node1 docker]# docker images
#倉庫名             #標籤                #鏡像ID             #建立時間            #大小
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
centos              latest              98d35105a391        7 days ago          192 MB

爲了加速鏡像構建、重複利用資源，Docker 會利用 中間層鏡像。因此在使用一段時間後，可能會看到一些依賴的中間層鏡像。使用-a參數來顯示中間層鏡像。

[root@node1 docker]# docker images  -a

按照指定格式輸出

docker images   --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

Docker commit

使用nginx 鏡像啓動一個容器，命名爲 webserver，而且把容器的80端口映射在宿主機的80端口。

docker run --name webserver -d -p 80:80 nginx

使用瀏覽器訪問宿主機的80端口，訪問到容器的web服務

咱們更改訪問頁面,使用exec命令進入容器，並執行bash命令，更改nginx的歡迎頁面內容

docker exec -it webserver bash
echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
exit

咱們修改了容器的存儲層，使用docker diff 查看文件的改動

[root@node1 docker]# docker diff webserver
C /usr
C /usr/share
C /usr/share/nginx
C /usr/share/nginx/html
C /usr/share/nginx/html/index.html
C /run
A /run/nginx.pid
C /var
C /var/cache
C /var/cache/nginx
A /var/cache/nginx/uwsgi_temp
A /var/cache/nginx/client_temp
A /var/cache/nginx/fastcgi_temp
A /var/cache/nginx/proxy_temp
A /var/cache/nginx/scgi_temp
C /root
A /root/.bash_history

定製好頁面以後，保存爲鏡像，當咱們運行一個容器的時候（若是不使用卷的話），咱們作的任何文件修改都會被記錄於容器存儲層裏。而 Docker 提供了一個 docker commit 命令，能夠將容器的存儲層保存下來成爲鏡像。換句話說，就是在原有鏡像的基礎上，再疊加上容器的存儲層，並構成新的鏡像。

docker commit \
    --author "xiaohou <xxx@163.com>" \
    --message "修改了默認網頁" \
    webserver \
    nginx:v2

使用docker image查看新的鏡像

[root@node1 docker]# docker images nginx
REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
nginx               v2                  2be7bf1f91da        About a minute ago   182 MB
nginx               latest              6b914bbcb89e        3 weeks ago          182 MB

還能夠用 docker history 具體查看鏡像內的歷史記錄，若是比較 nginx:latest 的歷史記錄

[root@node1 docker]# docker history nginx:v2
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
2be7bf1f91da        2 minutes ago       nginx -g daemon off;                            97 B                修改了默認網頁
6b914bbcb89e        3 weeks ago         /bin/sh -c #(nop)  CMD ["nginx" "-g" "daem...   0 B                 
<missing>           3 weeks ago         /bin/sh -c #(nop)  EXPOSE 443/tcp 80/tcp        0 B                 
<missing>           3 weeks ago         /bin/sh -c ln -sf /dev/stdout /var/log/ngi...   0 B                 
<missing>           3 weeks ago         /bin/sh -c apt-key adv --keyserver hkp://p...   58.8 MB             
<missing>           3 weeks ago         /bin/sh -c #(nop)  ENV NGINX_VERSION=1.11....   0 B                 
<missing>           3 weeks ago         /bin/sh -c #(nop)  MAINTAINER NGINX Docker...   0 B                 
<missing>           3 weeks ago         /bin/sh -c #(nop)  CMD ["/bin/bash"]            0 B                 
<missing>           3 weeks ago         /bin/sh -c #(nop) ADD file:41ac8d85ee35954...   123 MB

新的鏡像定製好後，咱們能夠來運行這個鏡像,訪問宿主機的81端口

docker run --name web2 -d -p 81:80 nginx:v2

慎用 docker commit

觀察以前的 docker diff webserver 的結果，你會發現除了真正想要修改的 /usr/share/nginx/html/index.html 文件外，還有不少文件被改動或添加了。若是是安裝軟件包、編譯構建，那會有大量的無關內容被添加進來，將會致使鏡像極爲臃腫。

使用 docker commit 意味着除了製做鏡像的人知道執行過什麼命令、怎麼生成的鏡像，別人根本無從得知。並且，即便是這個製做鏡像的人，過一段時間後也沒法記清具體在操做的。

若是使用 docker commit 製做鏡像，因爲只在當前層操做，後期修改的話，每一次修改都會讓鏡像更加臃腫一次，所刪除的上一層的東西並不會丟失，會一直如影隨形的跟着這個鏡像，即便根本沒法訪問到™。這會讓鏡像更加臃腫。

docker commit 命令除了學習以外，還有一些特殊的應用場合，好比被入侵後保存現場等。可是，不要使用 docker commit 定製鏡像，定製行爲應該使用 Dockerfile 來完成。

Dockerfile

Dockerfile是一個文本文件，用來來構建、定製鏡像。以前使用 docker commit 說起的沒法重複的問題、鏡像構建透明性的問題、體積的問題就都會解決。

使用docker file 定製nginx鏡像

mkdir ~/mynginx
cd ~/mynginx
vim   Dockerfile
FROM nginx
RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

FROM：

指定一個基礎鏡像，能夠直接拿來使用的服務類的鏡像，如ubuntu、debian、centos、fedora、alpine、nginx、redis、mongo、mysql、httpd、php、tomcat 等。

指定一個空白鏡像

FROM scratch
RUN  ...

RUN:

RUN 指令是用來執行命令行命令。其格式有兩種。

• SHELL格式：

RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

• exec 格式:

RUN ["可執行文件", "參數1", "參數2"]

在使用shell模式編寫時，不建議每一個命令都寫一層RUN，每個 RUN 的行爲，就和剛纔咱們手工創建鏡像的過程同樣：新創建一層，在其上執行這些命令，執行結束後，commit 這一層的修改，構成新的鏡像。Union FS 是有最大層數限制的，好比 AUFS，曾經是最大不得超過 42 層，如今是不得超過 127 層。

正確dockerfile寫法

FROM debian:jessie

RUN buildDeps='gcc libc6-dev make' \
    && apt-get update \
    && apt-get install -y $buildDeps \
    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \
    && mkdir -p /usr/src/redis \
    && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
    && make -C /usr/src/redis \
    && make -C /usr/src/redis install \
    && rm -rf /var/lib/apt/lists/* \
    && rm redis.tar.gz \
    && rm -r /usr/src/redis \
    && apt-get purge -y --auto-remove $buildDeps

不建議的寫法：

FROM debian:jessie

RUN apt-get update
RUN apt-get install -y gcc libc6-dev make
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz"
RUN mkdir -p /usr/src/redis
RUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1
RUN make -C /usr/src/redis
RUN make -C /usr/src/redis install

構建鏡像

cd ~/mynginx/
# -t:指定標籤
docker build -t nginx:v3 .

鏡像構建上下文（Context）

在 docker build 命令最後有一個 . 。. 表示當前目錄，而 Dockerfile 就在當前目錄，所以很多初學者覺得這個路徑是在指定 Dockerfile 所在路徑，這麼理解實際上是不許確的。若是對應上面的命令格式，你可能會發現，這是在指定上下文路徑。那麼什麼是上下文呢？

首先咱們要理解 docker build 的工做原理。Docker 在運行時分爲 Docker 引擎（也就是服務端守護進程）和客戶端工具。Docker 的引擎提供了一組 REST API，被稱爲 Docker Remote API，而如 docker 命令這樣的客戶端工具，則是經過這組 API 與 Docker 引擎交互，從而完成各類功能。所以，雖然表面上咱們好像是在本機執行各類 docker 功能，但實際上，一切都是使用的遠程調用形式在服務端（Docker 引擎）完成。也由於這種 C/S 設計，讓咱們操做遠程服務器的 Docker 引擎變得垂手可得。

當咱們進行鏡像構建的時候，並不是全部定製都會經過 RUN 指令完成，常常會須要將一些本地文件複製進鏡像，好比經過 COPY 指令、ADD 指令等。而 docker build 命令構建鏡像，其實並不是在本地構建，而是在服務端，也就是 Docker 引擎中構建的。那麼在這種客戶端/服務端的架構中，如何才能讓服務端得到本地文件呢？

這就引入了上下文的概念。當構建的時候，用戶會指定構建鏡像上下文的路徑，docker build 命令得知這個路徑後，會將路徑下的全部內容打包，而後上傳給 Docker 引擎。這樣 Docker 引擎收到這個上下文包後，展開就會得到構建鏡像所需的一切文件。

若是在 Dockerfile 中這麼寫：

COPY ./package.json /app/

這並非要複製執行 docker build 命令所在的目錄下的 package.json，也不是複製 Dockerfile 所在目錄下的 package.json，而是複製 上下文（context） 目錄下的 package.json。

所以，COPY 這類指令中的源文件的路徑都是相對路徑。這也是初學者常常會問的爲何 COPY ../package.json /app 或者 COPY /opt/xxxx /app 沒法工做的緣由，由於這些路徑已經超出了上下文的範圍，Docker 引擎沒法得到這些位置的文件。若是真的須要那些文件，應該將它們複製到上下文目錄中去。

若是觀察 docker build 輸出，咱們其實已經看到了這個發送上下文的過程：

[root@node1 mynginx]# docker build -t nginx:v3 .
Sending build context to Docker daemon 2.048 kB
Step 1/2 : FROM nginx
 ---> 6b914bbcb89e
Step 2/2 : RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
 ---> Running in e3405aef8ac5
 ---> 11c14b5ee07d
Removing intermediate container e3405aef8ac5
Successfully built 11c14b5ee07d

理解構建上下文對於鏡像構建是很重要的，避免犯一些不該該的錯誤。好比有些初學者在發現 COPY /opt/xxxx /app 不工做後，因而乾脆將 Dockerfile 放到了硬盤根目錄去構建，結果發現 docker build 執行後，在發送一個幾十 GB 的東西，極爲緩慢並且很容易構建失敗。那是由於這種作法是在讓 docker build 打包整個硬盤，這顯然是使用錯誤。

通常來講，應該會將 Dockerfile 置於一個空目錄下，或者項目根目錄下。若是該目錄下沒有所需文件，那麼應該把所需文件複製一份過來。若是目錄下有些東西確實不但願構建時傳給 Docker 引擎，那麼能夠用 .gitignore 同樣的語法寫一個 .dockerignore，該文件是用於剔除不須要做爲上下文傳遞給 Docker 引擎的。

那麼爲何會有人誤覺得 . 是指定 Dockerfile 所在目錄呢？這是由於在默認狀況下，若是不額外指定 Dockerfile 的話，會將上下文目錄下的名爲 Dockerfile 的文件做爲 Dockerfile。

這只是默認行爲，實際上 Dockerfile 的文件名並不要求必須爲 Dockerfile，並且並不要求必須位於上下文目錄中，好比能夠用 -f ../Dockerfile.php 參數指定某個文件做爲 Dockerfile。

固然，通常你們習慣性的會使用默認的文件名 Dockerfile，以及會將其置於鏡像構建上下文目錄中。

Dockerfile 指令

COPY：

格式：

• SHELL格式：

COPY <源路徑>... <目標路徑>

• exec 格式:

COPY ["<源路徑1>",... "<目標路徑>"]

"源路徑"能夠是多個，也能夠是通配符，其通配符規則要知足 Go 的 filepath.Match 規則，如：

COPY hom* /mydir/
COPY hom?.txt /mydir/

"目標路徑"能夠是容器內的絕對路徑，也能夠是相對於工做目錄的相對路徑（工做目錄能夠用 WORKDIR 指令來指定）。目標路徑不須要事先建立，若是目錄不存在會在複製文件前先行建立缺失目錄。

使用 COPY 指令，源文件的各類元數據都會保留。好比讀、寫、執行權限、文件變動時間等。這個特性對於鏡像定製頗有用。特別是構建相關文件都在使用 Git 進行管理的時候。

ADD

"源路徑"能夠是一個 URL，這種狀況下，Docker 引擎會試圖去下載這個連接的文件放到"目標路徑"。下載後的文件權限自動設置爲600。

若是這並非想要的權限，那麼還須要增長額外的一層 RUN 進行權限調整。

若是"源路徑"爲一個 tar.gzip,tar.bzip2,tar.xz的文件，ADD 指令將會自動解壓縮這個壓縮文件到"目標路徑"去。

FROM scratch
ADD ubuntu-xenial-core-cloudimg-amd64-root.tar.gz /

在 Docker 官方的最佳實踐文檔中要求，儘量的使用 COPY，由於 COPY 的語義很明確，就是複製文件而已，而 ADD 則包含了更復雜的功能，其行爲也不必定很清晰。最適合使用 ADD 的場合，就是所說起的須要自動解壓縮的場合。

CMD

CMD 指令的格式和 RUN 類似，也是兩種格式：

• shell 格式：

CMD <命令>

• exec 格式：

CMD ["可執行文件", "參數1", "參數2"...]

• 參數列表格式：

CMD ["參數1", "參數2"...]。

在指定了 ENTRYPOINT 指令後，用 CMD 指定具體的參數。

以前介紹容器的時候曾經說過，Docker 不是虛擬機，容器就是進程。既然是進程，那麼在啓動容器的時候，須要指定所運行的程序及參數。CMD 指令就是用於指定默認的容器主進程的啓動命令的。

在運行時能夠指定新的命令來替代鏡像設置中的這個默認命令，鏡像默認的 CMD 是 /bin/bash ，若是咱們直接 docker run -it centos 的話，會直接進入 bash。咱們也能夠在運行時指定運行別的命令，如 docker run -it ubuntu cat /etc/os-release。這就是用 cat /etc/os-release命令替換了默認的 /bin/bash 命令了，輸出了系統版本信息。

在指令格式上，通常推薦使用 exec 格式，這類格式在解析時會被解析爲 JSON 數組，所以必定要使用雙引號 "，而不要使用單引號。

若是使用 shell 格式的話，實際的命令會被包裝爲sh -c 的參數的形式進行執行。好比：

CMD echo $HOME

在實際執行中，會將其變動爲：

CMD [ "sh", "-c", "echo $HOME" ]

這就是爲何咱們可使用環境變量的緣由，由於這些環境變量會被 shell 進行解析處理。

Docker 不是虛擬機，容器中的應用都應該之前臺執行，而不是像虛擬機、物理機裏面那樣，用 upstart/systemd 去啓動後臺服務，容器內沒有後臺服務的概念。

一些初學者將 CMD 寫爲：

CMD service nginx start

而後發現容器執行後就當即退出了。甚至在容器內去使用 systemctl 命令結果卻發現根本執行不了。這就是由於沒有搞明白前臺、後臺的概念，沒有區分容器和虛擬機的差別，依舊在以傳統虛擬機的角度去理解容器。

對於容器而言，其啓動程序就是容器應用進程，容器就是爲了主進程而存在的，主進程退出，容器就失去了存在的意義，從而退出，其它輔助進程不是它須要關心的東西。

而使用service nginx start命令，則是但願 upstart 來之後臺守護進程形式啓動 nginx 服務。而剛纔說了 CMD service nginx start 會被理解爲 CMD [ "sh", "-c", "service nginx start"]，所以主進程其實是 sh。那麼當 service nginx start 命令結束後，sh 也就結束了，sh 做爲主進程退出了，天然就會令容器退出。

正確的作法是直接執行 nginx 可執行文件，而且要求之前臺形式運行。好比：

CMD ["nginx", "-g", "daemon off;"]

ENTRYPOINT

ENTRYPOINT 的目的和 CMD 同樣，都是在指定容器啓動程序及參數。ENTRYPOINT 在運行時也能夠替代，不過比 CMD 要略顯繁瑣，須要經過 docker run 的參數 --entrypoint 來指定。

當指定了 ENTRYPOINT 後，CMD 的含義就發生了改變，再也不是直接的運行其命令，而是將 CMD 的內容做爲參數傳給 ENTRYPOINT 指令，換句話說實際執行時，將變爲：

<ENTRYPOINT> "<CMD>"

場景一：讓鏡像變成像命令同樣使用

假設咱們須要一個得知本身當前公網 IP 的鏡像，那麼能夠先用 CMD 來實現：

mkdir ~/myip/
cd ~/myip/
tee Dockerfile <<'EOF'
FROM centos
RUN  yum -y install wget \
     && wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo \
     &&wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo \
     &&yum -y install  curl
CMD [ "curl", "-s", "http://ip.cn" ]
EOF
docker build  -t myip .

啓動一個容器測試

[root@node1 myip]# docker run  myip
當前 IP：123.117.85.77 來自：北京市 聯通

這麼看起來好像能夠直接把鏡像當作命令使用了，若是咱們但願加參數呢？從上面的 CMD 中能夠看到實質的命令是 curl，那麼若是咱們但願顯示 HTTP 頭信息，就須要加上 -i 參數。那麼咱們能夠直接加 -i 參數給 docker run myip 麼？

[root@node1 myip]# docker rum myip -i
unknown shorthand flag: 'i' in -i
See 'docker --help'.
...

跟在鏡像名後面的是 command，運行時會替換 CMD 的默認值。所以這裏的 -i 替換了原來的 CMD，而不是添加在原來的 curl -s http://ip.cn 後面。而 -i 根本不是命令，因此天然找不到。

若是咱們但願加入 -i 這參數，咱們就必須從新完整的輸入這個命令：

[root@node1 myip]# docker run myip curl -s http://ip.cn -i
HTTP/1.1 200 OK
Server: nginx/1.10.0 (Ubuntu)
Date: Fri, 24 Mar 2017 02:21:43 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive

當前 IP：123.117.85.77 來自：北京市

而使用 ENTRYPOINT 就能夠給 docker 傳參，修改docker鏡像

cd ~/myip/
tee Dockerfile <<'EOF'
FROM centos
RUN  yum -y install wget \
     && wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo \
     &&wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo \
     &&yum -y install  curl
ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]
EOF
docker build  -t myip .

再次運行

[root@node1 myip]# docker run myip
當前 IP：123.117.85.77 來自：北京市


[root@node1 myip]# docker run myip -i
HTTP/1.1 200 OK
Server: nginx/1.10.0 (Ubuntu)
Date: Fri, 24 Mar 2017 02:24:42 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive

當前 IP：123.117.85.77 來自：北京市

場景二：應用運行前的準備工做

redis的官方dockerfile https://github.com/docker-library/redis/blob/master/3.2/alpine/Dockerfile

FROM alpine:3.5
...
RUN addgroup -S redis && adduser -S -G redis redis
...
ENTRYPOINT ["docker-entrypoint.sh"]

EXPOSE 6379
CMD [ "redis-server" ]

能夠看到其中爲了 redis 服務建立了 redis 用戶，並在最後指定了 ENTRYPOINT 爲 docker-entrypoint.sh 腳本。

#!/bin/sh
...
# allow the container to be started with `--user`
if [ "$1" = 'redis-server' -a "$(id -u)" = '0' ]; then
    chown -R redis .
    exec su-exec redis "$0" "$@"
fi

exec "$@"

該腳本的內容就是根據 CMD 的內容來判斷，若是是 redis-server 的話，則切換到 redis 用戶身份啓動服務器，不然依舊使用 root 身份執行。好比：

$ docker run -it redis id
uid=0(root) gid=0(root) groups=0(root)

ENV 設置環境變量

格式有兩種：

• ENV <key> <value>
• ENV <key1>=<value1> <key2>=<value2>...

這個指令很簡單，就是設置環境變量而已，不管是後面的其它指令，如 RUN，仍是運行時的應用，均可以直接使用這裏定義的環境變量。

ENV VERSION=1.0 DEBUG=on \
    NAME="Happy Feet"

這個例子中演示瞭如何換行，以及對含有空格的值用雙引號括起來的辦法，這和 Shell 下的行爲是一致的。

定義了環境變量，那麼在後續的指令中，就可使用這個環境變量。好比在官方 node 鏡像 Dockerfile中，就有相似這樣的代碼：

ENV NODE_VERSION 7.2.0

RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
  && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc" \
  && gpg --batch --decrypt --output SHASUMS256.txt SHASUMS256.txt.asc \
  && grep " node-v$NODE_VERSION-linux-x64.tar.xz\$" SHASUMS256.txt | sha256sum -c - \
  && tar -xJf "node-v$NODE_VERSION-linux-x64.tar.xz" -C /usr/local --strip-components=1 \
  && rm "node-v$NODE_VERSION-linux-x64.tar.xz" SHASUMS256.txt.asc SHASUMS256.txt \
  && ln -s /usr/local/bin/node /usr/local/bin/nodejs

在這裏先定義了環境變量 NODE_VERSION，其後的 RUN 這層裏，屢次使用 $NODE_VERSION 來進行操做定製。能夠看到，未來升級鏡像構建版本的時候，只須要更新 7.2.0 便可，Dockerfile 構建維護變得更輕鬆了。

下列指令能夠支持環境變量展開： ADD、COPY、ENV、EXPOSE、LABEL、USER、WORKDIR、VOLUME、STOPSIGNAL、ONBUILD。

能夠從這個指令列表裏感受到，環境變量可使用的地方不少，很強大。經過環境變量，咱們可讓一份 Dockerfile 製做更多的鏡像，只需使用不一樣的環境變量便可。

ARG 構建參數

• 格式：

ARG <參數名>[=<默認值>]

構建參數和 ENV 的效果同樣，都是設置環境變量。所不一樣的是，ARG 所設置的構建環境的環境變量，在未來容器運行時是不會存在這些環境變量的。不建議 ARG 保存密碼之類的信息，由於 docker history 仍是能夠看到全部值的。

VOLUME 定義匿名卷

• 格式：

VOLUME ["<路徑1>", "<路徑2>"...]
VOLUME <路徑>

以前咱們說過，容器運行時應該儘可能保持容器存儲層不發生寫操做，對於數據庫類須要保存動態數據的應用，其數據庫文件應該保存於卷(volume)中，後面的章節咱們會進一步介紹 Docker 卷的概念。爲了防止運行時用戶忘記將動態文件所保存目錄掛載爲卷，在 Dockerfile 中，咱們能夠事先指定某些目錄掛載爲匿名卷，這樣在運行時若是用戶不指定掛載，其應用也能夠正常運行，不會向容器存儲層寫入大量數據。

VOLUME /data

也能夠運行時覆蓋這個掛載設置。好比：

docker run -d -v mydata:/data xxxx

在這行命令中，就使用了 mydata 這個命名卷掛載到了 /data 這個位置，替代了 Dockerfile 中定義的匿名卷的掛載配置。

EXPOSE 聲明端口

• 格式：

EXPOSE <端口1> [<端口2>...]

EXPOSE 指令是聲明運行時容器提供服務端口，在運行時並不會由於這個聲明應用就會開啓這個端口的服務。

在 Dockerfile 中寫入這樣的聲明有兩個好處:

1. 幫助鏡像使用者理解這個鏡像服務的守護端口，以方便配置映射

2. 在運行時使用隨機端口映射時，也就是 docker run -P 時，會自動隨機映射 EXPOSE 的端口。

此外，在早期 Docker 版本中還有一個特殊的用處。之前全部容器都運行於默認橋接網絡中，所以全部容器互相之間均可以直接訪問，這樣存在必定的安全性問題。因而有了一個 Docker 引擎參數 --icc=false，當指定該參數後，容器間將默認沒法互訪，除非互相間使用了 --links 參數的容器才能夠互通，而且只有鏡像中 EXPOSE 所聲明的端口才能夠被訪問。這個 --icc=false 的用法，在引入了 docker network 後已經基本不用了，經過自定義網絡能夠很輕鬆的實現容器間的互聯與隔離。

WORKDIR 指定工做目錄

• 格式:

WORKDIR <工做目錄路徑>

使用 WORKDIR 指令能夠來指定工做目錄（或者稱爲當前目錄），之後各層的當前目錄就被改成指定的目錄，如該目錄不存在，WORKDIR 會幫你創建目錄。
以前提到一些初學者常犯的錯誤是把 Dockerfile 等同於 Shell 腳原本書寫，這種錯誤的理解還可能會致使出現下面這樣的錯誤：

RUN cd /app
RUN echo "hello" > world.txt

若是將這個 Dockerfile 進行構建鏡像運行後，會發現找不到 /app/world.txt 文件，或者其內容不是hello。緣由其實很簡單，在 Shell 中，連續兩行是同一個進程執行環境，所以前一個命令修改的內存狀態，會直接影響後一個命令；而在 Dockerfile 中，這兩行 RUN 命令的執行環境根本不一樣，是兩個徹底不一樣的容器。這就是對 Dokerfile 構建分層存儲的概念不瞭解所致使的錯誤。

以前說過每個 RUN 都是啓動一個容器、執行命令、而後提交存儲層文件變動。第一層 RUN cd /app 的執行僅僅是當前進程的工做目錄變動，一個內存上的變化而已，其結果不會形成任何文件變動。而到第二層的時候，啓動的是一個全新的容器，跟第一層的容器更徹底不要緊，天然不可能繼承前一層構建過程當中的內存變化。

所以若是須要改變之後各層的工做目錄的位置，那麼應該使用 WORKDIR 指令。

USER 指定當前用戶

• 格式：

USER <用戶名>

USER 指令和 WORKDIR 類似，都是改變環境狀態並影響之後的層。WORKDIR 是改變工做目錄，USER 則是改變以後層的執行 RUN, CMD 以及 ENTRYPOINT 這類命令的身份。

固然，和 WORKDIR 同樣，USER 只是幫助你切換到指定用戶而已，這個用戶必須是事先創建好的，不然沒法切換。

RUN groupadd -r redis && useradd -r -g redis redis
USER redis
RUN [ "redis-server" ]

HEALTHCHECK 健康檢查

• 格式：

HEALTHCHECK [選項] CMD <命令>：設置檢查容器健康情況的命令
HEALTHCHECK NONE：若是基礎鏡像有健康檢查指令，使用這行能夠屏蔽掉其健康檢查指令

HEALTHCHECK 指令是告訴 Docker 應該如何進行判斷容器的狀態是否正常，這是 Docker 1.12 引入的新指令。

在沒有 HEALTHCHECK 指令前，Docker 引擎只能夠經過容器內主進程是否退出來判斷容器是否狀態異常。不少狀況下這沒問題，可是若是程序進入死鎖狀態，或者死循環狀態，應用進程並不退出，可是該容器已經沒法提供服務了。在 1.12 之前，Docker 不會檢測到容器的這種狀態，從而不會從新調度，致使可能會有部分容器已經沒法提供服務了卻還在接受用戶請求。

而自 1.12 以後，Docker 提供了 HEALTHCHECK 指令，經過該指令指定一行命令，用這行命令來判斷容器主進程的服務狀態是否還正常，從而比較真實的反應容器實際狀態。

當在一個鏡像指定了 HEALTHCHECK 指令後，用其啓動容器，初始狀態會爲 starting，在 HEALTHCHECK 指令檢查成功後變爲 healthy，若是連續必定次數失敗，則會變爲 unhealthy。

HEALTHCHECK 支持下列選項：

--interval=<間隔>：兩次健康檢查的間隔，默認爲 30 秒；
--timeout=<時長>：健康檢查命令運行超時時間，若是超過這個時間，本次健康檢查就被視爲失敗，默認 30 秒；
--retries=<次數>：當連續失敗指定次數後，則將容器狀態視爲 unhealthy，默認 3 次。

和 CMD, ENTRYPOINT 同樣，HEALTHCHECK 只能夠出現一次，若是寫了多個，只有最後一個生效。

在 HEALTHCHECK [選項] CMD 後面的命令，格式和 ENTRYPOINT 同樣，分爲 shell 格式，和 exec 格式。命令的返回值決定了該次健康檢查的成功與否：0：成功；1：失敗；2：保留，不要使用這個值。

假設咱們有個鏡像是個最簡單的 Web 服務，咱們但願增長健康檢查來判斷其 Web 服務是否在正常工做，咱們能夠用 curl 來幫助判斷，其 Dockerfile 的 HEALTHCHECK 能夠這麼寫：

mkdir ~/nginxcheck
cd ~/nginxcheck
vim Dockerfile
FROM nginx
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
HEALTHCHECK --interval=5s --timeout=3s \
  CMD curl -fs http://localhost/ || exit 1

docker build -t myweb:v1 .

這裏咱們設置了每 5 秒檢查一次（這裏爲了試驗因此間隔很是短，實際應該相對較長），若是健康檢查命令超過 3 秒沒響應就視爲失敗，而且使用 curl -fs http://localhost/ || exit 1 做爲健康檢查命令。

啓動測試

docker run -d --name myweb -p 80:82 myweb:v1

查看

[root@node1 nginxcheck]# docker ps -f name=myweb
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                    PORTS                                 NAMES
beb18dcc15fe        myweb:v1            "nginx -g 'daemon ..."   22 seconds ago      Up 21 seconds (healthy)   80/tcp, 443/tcp, 0.0.0.0:80->82/tcp   myweb

若是健康檢查連續失敗超過了重試次數，狀態就會變爲 (unhealthy)。

健康檢查命令的輸出（包括 stdout 以及 stderr）都會被存儲於健康狀態裏，能夠用 docker inspect 來查看。

docker inspect --format '{{json .State.Health}}' web | python -m json.tool

ONBUILD 爲他人作嫁衣

ONBUILD 是一個特殊的指令，它後面跟的是其它指令，好比 RUN, COPY 等，而這些指令，在當前鏡像構建時並不會被執行。只有當以當前鏡像爲基礎鏡像，去構建下一級鏡像的時候纔會被執行。
例如：

FROM node:slim
RUN "mkdir /app"
WORKDIR /app
ONBUILD COPY ./package.json /app
ONBUILD RUN [ "npm", "install" ]
ONBUILD COPY . /app/
CMD [ "npm", "start" ]

在構建基礎鏡像的時候，包含ONBUILD這三行並不會被執行，可是當把這個鏡像做爲基礎鏡像構建時，這三行就會執行。

#首先構建基礎鏡像
docker build -t my-node .

#在其餘項目須要使用這個Dockerfile製做的鏡像做爲基礎鏡像時，直接寫Dockerfile，基礎鏡像的三行會在子Dockerfile中執行
FROM my-node

其餘製做鏡像方法

除了標準的使用 Dockerfile 生成鏡像的方法外，因爲各類特殊需求和歷史緣由，還提供了一些其它方法用以生成鏡像。

從 rootfs 壓縮包導入

格式：docker import [選項] <文件>|<URL>|- [<倉庫名>[:<標籤>]]

壓縮包能夠是本地文件、遠程 Web 文件，甚至是從標準輸入中獲得。壓縮包將會在鏡像 / 目錄展開，並直接做爲鏡像第一層提交。

好比咱們想要建立一個 OpenVZ 的 Ubuntu 14.04 模板的鏡像：

docker import \
    http://download.openvz.org/template/precreated/ubuntu-14.04-x86_64-minimal.tar.gz \
    openvz/ubuntu:14.04

這條命令自動下載了 ubuntu-14.04-x86_64-minimal.tar.gz 文件，而且做爲根文件系統展開導入，並保存爲鏡像 openvz/ubuntu:14.04。

docker save 和 docker load

Docker 還提供了 docker load 和 docker save 命令，用以將鏡像保存爲一個 tar 文件，而後傳輸到另外一個位置上，再加載進來。這是在沒有 Docker Registry 時的作法，如今已經不推薦，鏡像遷移應該直接使用 Docker Registry，不管是直接使用 Docker Hub 仍是使用內網私有 Registry 均可以。

使用 docker save 命令能夠將鏡像保存爲歸檔文件。

docker pull alpine
docker save alpine |gzip > alpine.tar.gz

而後咱們將 alpine-latest.tar.gz 文件複製到了到了另外一個機器上，能夠用下面這個命令加載鏡像：

docker load -i alpine-latest.tar.gz

使用容器

啓動容器

啓動容器有兩種方式，一種是基於鏡像新建一個容器並啓動，另一個是將在終止狀態（stopped）的容器從新啓動。

容器的啓動流程

當利用 docker run 來建立容器時，Docker 在後臺運行的標準操做包括：

• 檢查本地是否存在指定的鏡像，不存在就從公有倉庫下載
• 利用鏡像建立並啓動一個容器
• 分配一個文件系統，並在只讀的鏡像層外面掛載一層可讀寫層
• 從宿主主機配置的網橋接口中橋接一個虛擬接口到容器中去
• 從地址池配置一個 ip 地址給容器
• 執行用戶指定的應用程序
• 執行完畢後容器被終止

使用docker run啓動

下面的命令輸出一個 「Hello World」，以後終止容器。

docker run centos /bin/echo 'Hello world'

啓動一個前臺的bash進程，-t 選項讓Docker分配一個僞終端（pseudo-tty）並綁定到容器的標準輸入上，-i 則讓容器的標準輸入保持打開。

docker run -t -i centos /bin/bash

使用docker start啓動已終止容器

docker start  容器名字或ID

查看容器的資源佔用,只有一個bash進程

[root@94b57792acbf /]# ps aux
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.0  0.1  11768  1932 ?        Ss   07:19   0:00 /bin/bash
root         56  0.0  0.1  47440  1672 ?        R+   07:27   0:00 ps aux

讓容器之後臺進程模式運行

更多的時候，須要讓 Docker在後臺運行而不是直接把執行命令的結果輸出在當前宿主機下。此時，能夠經過添加 -d 參數來實現。

使用例子來體驗區別：
不使用 -d 參數：

[root@node1 ~]# docker run centos /bin/bash -c "while true; do echo hello world; sleep 1; done"
hello world
hello world
hello world
hello world

全部的輸出都輸出到宿主機。

加-d參數

[root@node1 ~]# docker run  -d centos /bin/bash -c "while true; do echo hello world; sleep 1; done"
a8e42575a9ff340c65f0023c77926b0f80051f53ade13c38847f0e8a6319ee63

此時容器會在後臺運行並不會把輸出的結果打印到宿主機上，可使用 docker logs 查看

[root@node1 ~]# docker logs a8e42575a9ff

注： 容器是否會長久運行，是和docker run指定的命令有關，和 -d 參數無關。

終止容器

docker stop {CONTAINER ID| NAMES}

對於上一章節中只啓動了一個bash的容器，用戶經過 exit 命令或 Ctrl+d 來退出終端時，所建立的容器馬上終止。

進入容器

attach 命令

[root@node1 ~]# docker run -dit centos /bin/bash
14c0b4a935f57317f25111aa55beed0f3329afe60871ca06c44a12acc4172140
[root@node1 ~]# docker ps 
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                 PORTS                                 NAMES
14c0b4a935f5        centos              "/bin/bash"              25 seconds ago      Up 24 seconds                                                dreamy_wiles

[root@node1 ~]# docker attach dreamy_wiles

可是使用 attach 命令有時候並不方便。當多個窗口同時 attach 到同一個容器的時候，全部窗口都會同步顯示。當某個窗口因命令阻塞時,其餘窗口也沒法執行操做了,使用attach命令退出使用ctrl+p+q 退出不影響容器運行。

nsenter 命令

安裝命令

yum -y install  util-linux

獲取容器PID

PID=$(docker inspect --format "{{ .State.Pid }}" dreamy_wiles)

進入容器

nsenter --target $PID --mount --uts --ipc --net --pid

導入導出容器

導出容器快照

docker export 7691a814370e > centos.tar

導入容器快照

cat centos.tar | sudo docker import - myimages/centos:v1.0

刪除容器

docker rm {CONTAINER ID| NAMES}

Docer 數據管理

Docker 內部管理數據主要有兩種方式：

• 數據卷（Data volumes）
• 數據卷容器（Data volume containers）

數據卷

數據卷是一個可供一個或多個容器使用的特殊目錄，它繞過 UFS，能夠提供不少有用的特性：

• 數據卷能夠在容器之間共享和重用
• 對數據卷的修改會立馬生效
• 對數據卷的更新，不會影響鏡像
• 數據卷默認會一直存在，即便容器被刪除

注意：數據卷的使用，相似於 Linux 下對目錄或文件進行 mount，鏡像中的被指定爲掛載點的目錄中的文件會隱藏掉，能顯示看的是掛載的數據卷。

使用 -v 標記也能夠指定掛載一個本地主機的目錄到容器中去。

docker run -dit --name test  -v /tmp:/opt:ro centos  /bin/bash

數據卷容器

數據卷容器，其實就是一個正常的容器，專門用來提供數據卷供其它容器掛載的。

docker run -dit -v /dbdata --name dbdata centos /bin/bash
[root@node1 ~]# docker attach dbdata
[root@a9642e6adf7b /]# touch /dbdata/{1..10}.txt

在其餘容器中使用 --volumes-from 來掛載 dbdata 容器中的數據卷。

docker run -dit --volumes-from dbdata --name db1 centos /bin/bash
docker run -dit --volumes-from dbdata --name db2 centos /bin/bash

驗證

[root@node1 ~]# docker attach db1
[root@87f964ea0f31 /]# ls /dbdata/
1.txt  10.txt  2.txt  3.txt  4.txt  5.txt  6.txt  7.txt  8.txt  9.txt

注意：使用 --volumes-from 參數所掛載數據卷的容器本身並不須要保持在運行狀態。

若是刪除了掛載的容器（包括 dbdata、db1 和 db2），數據卷並不會被自動刪除。若是要刪除一個數據卷，必須在刪除最後一個還掛載着它的容器時使用 docker rm -v 命令來指定同時刪除關聯的容器。 這可讓用戶在容器之間升級和移動數據卷。

利用數據卷容器來備份、恢復、遷移數據卷

能夠利用數據卷對其中的數據進行進行備份、恢復和遷移。

備份

首先使用 --volumes-from 標記來建立一個加載 dbdata 容器卷的容器，並從主機掛載/opt/backup到容器的 /backup 目錄。命令以下：

docker run --volumes-from dbdata -v /opt/backup:/backup centos tar cvf /backup/backup.tar /dbdata

恢復

若是要恢復數據到一個容器，首先建立一個帶有空數據卷的容器 dbdata2。

docker run -v /dbdata --name dbdata2 centos /bin/bash

而後建立另外一個容器，掛載 dbdata2 容器卷中的數據卷，並使用 untar 解壓備份文件到掛載的容器卷中。

docker run --volumes-from dbdata2 -v /opt/backup:/backup centos tar xvf /backup/backup.tar

爲了查看/驗證恢復的數據，能夠再啓動一個容器掛載一樣的容器捲來查看

docker run --volumes-from dbdata2 centos /bin/ls /dbdata

Docker registry

Registry 和 Repository 的區別

註冊服務器（Registry），是管理倉庫的具體服務器，每一個服務器上能夠有多個倉庫（Repository），而每一個倉庫（Repository）下面有多個鏡像。

配置registry

registry若是想要別人可使用，須要https才能夠，咱們能夠利用openssl來搭建私有的CA服務器，用以簽名、頒發證書，管理已簽名證書和已吊銷證書等。

搭建私有CA

初始化CA環境，在/etc/pki/CA/下創建證書索引數據庫文件index.txt和序列號文件serial，併爲證書序列號文件提供初始值。

touch /etc/pki/CA/{index.txt,serial}
echo 01 > /etc/pki/CA/serial

生成密鑰並保存到/etc/pki/CA/private/cakey.pem

(umask 077;openssl genrsa -out  /etc/pki/CA/private/cakey.pem 2048)

生成根證書

openssl req -new -x509 -key  /etc/pki/CA/private/cakey.pem -out /etc/pki/CA/cacert.pem -days 3650

填寫的信息

Country Name (2 letter code) [XX]:CN
State or Province Name (full name) []:Beijing
Locality Name (eg, city) [Default City]:Beijing
Organization Name (eg, company) [Default Company Ltd]:mycompany
Organizational Unit Name (eg, section) []:ops
Common Name (eg, your name or your server's hostname) []:registry.mycompany.com
Email Address []:admin@mycompany.com

使Linux系統信任根證書

cat /etc/pki/CA/cacert.pem >> /etc/pki/tls/certs/ca-bundle.crt

簽發證書

安裝nginx

yum -y install nginx

建立ssl目錄用來存放密鑰文件和證書申請文件

mkdir  /etc/nginx/ssl

建立密鑰文件和證書申請文件

(umask 077;openssl genrsa -out /etc/nginx/ssl/docker.key 2048)
openssl req -new -key /etc/nginx/ssl/docker.key -out /etc/nginx/ssl/docker.csr

填寫的申請信息前四項要和私有CA的信息一致

Country Name (2 letter code) [XX]:CN
State or Province Name (full name) []:Beijing
Locality Name (eg, city) [Default City]:Beijing
Organization Name (eg, company) [Default Company Ltd]:mycompany
Organizational Unit Name (eg, section) []:ops
Common Name (eg, your name or your server's hostname) []:registry.mycompany.com
Email Address []:admin@mycompany.com
#直接回車
A challenge password []:
An optional company name []:

簽署，證書

[root@node1 ~]# openssl ca -in /etc/nginx/ssl/docker.csr -out /etc/nginx/ssl/docker.crt -days 3650
Using configuration from /etc/pki/tls/openssl.cnf
Check that the request matches the signature
Signature ok
Certificate Details:
        Serial Number: 1 (0x1)
        Validity
            Not Before: Mar 30 08:12:58 2017 GMT
            Not After : Mar 28 08:12:58 2027 GMT
        Subject:
            countryName               = CN
            stateOrProvinceName       = Beijing
            organizationName          = mycompany
            organizationalUnitName    = ops
            commonName                = registry.mycompany.com
            emailAddress              = admin@mycompany.com
        X509v3 extensions:
            X509v3 Basic Constraints: 
                CA:FALSE
            Netscape Comment: 
                OpenSSL Generated Certificate
            X509v3 Subject Key Identifier: 
                59:27:56:F3:67:46:4B:6D:A5:1B:66:C0:D8:C7:7D:0F:CA:90:C2:ED
            X509v3 Authority Key Identifier: 
                keyid:76:4A:E0:BB:91:F5:0C:B2:67:2E:D1:3C:74:2B:05:F6:2C:A9:9B:7B

Certificate is to be certified until Mar 28 08:12:58 2027 GMT (3650 days)
Sign the certificate? [y/n]:y


1 out of 1 certificate requests certified, commit? [y/n]y
Write out database with 1 new entries
Data Base Updated

檢查index.txt和serial序列號更新

[root@node1 ~]# cat /etc/pki/CA/index.txt
V    270328055023Z        01    unknown    /C=CN/ST=Beijing/O=mycompany/OU=ops/CN=registry.mycompany.com/emailAddress=admin@mycompany.com

[root@node1 ~]# cat /etc/pki/CA/serial
02

基於localhost搭建docker-registry

啓動registry

docker run -d -p 5000:5000 --restart=always --name registry -v /opt/registry:/var/lib/registry registry:2

從dockerhub下載centos鏡像，使用docker tag 將 centos 這個鏡像標記爲 localhost:5000/centos

docker pull centos && docker tag centos localhost:5000/centos

使用docker push 上傳標記的鏡像

docker push localhost:5000/centos

從私有倉庫下載鏡像

docker pull  localhost:5000/centos

配置nginx反向代理docker registry

爲nginx添加認證

yum -y install httpd-tools
htpasswd -cb /etc/nginx/conf.d/docker-registry.htpasswd admin admin

添加nginx的server

[root@node1 ~]# cat /etc/nginx/conf.d/docker-registry.conf
upstream docker-registry {
    server 127.0.0.1:5000;
}
server {
        listen       443;
        server_name           registry.mycompany.com;
        ssl                   on;
        ssl_certificate       /etc/nginx/ssl/docker.crt;
        ssl_certificate_key   /etc/nginx/ssl/docker.key;
        client_max_body_size 0;
        chunked_transfer_encoding on;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        location / {
               auth_basic   "Docker registry";
               auth_basic_user_file /etc/nginx/conf.d/docker-registry.htpasswd;
               proxy_pass  http://docker-registry;
        }
         location /_ping{
               auth_basic off;
               proxy_pass  http://docker-registry;
               }
         location /v1/_ping{
               auth_basic off;
               proxy_pass  http://docker-registry;
               }
}

重啓nginx

systemctl restart nginx

修改hosts

10.0.7.1    registry.mycompany.com

測試

[root@node1 ~]# docker login registry.mycompany.com
Username: admin
Password: 
Login Succeeded

上傳鏡像

docker tag centos registry.mycompany.com/centos
docker push registry.mycompany.com/centos

查看

curl --user admin:admin  https://registry.mycompany.com/v2/_catalog
{"repositories":["centos"]}

配置局域網內其餘機器認證

修改hosts

vim /etc/hosts
10.0.7.1    registry.mycompany.com

一樣的系統版本,直接覆蓋ca-bundle.crt，

scp -rp /etc/pki/tls/certs/ca-bundle.crt  root@10.0.7.2:/etc/pki/tls/certs/ca-bundle.crt

不一樣版本把CA的密鑰發送到客戶機，並添加到ca-bundle.crt

scp -rp  /etc/pki/CA/cacert.pem root@10.0.7.2:/etc/pki/CA/cacert.pem
cat /etc/pki/CA/cacert.pem >> /etc/pki/tls/certs/ca-bundle.crt

重啓docker，若是不重啓會出現docker提示x509證書沒有受權

systemctl daemon-reload
systemctl restart docker

驗證

[root@node1 ~]# curl --user admin:admin  https://registry.mycompany.com/v2/_catalog
{"repositories":["centos"]}
[root@node1 ~]# docker login registry.mycompany.com
Username: admin
Password: 
Login Succeeded
[root@node1 ~]# docker pull registry.mycompany.com/centos
Using default tag: latest
latest: Pulling from centos
4969bbd91a1e: Pull complete 
Digest: sha256:d7f3db1caf4ea76117abce89709ebfc66c9339e13866016b8b2e4eee3ab4bea0
Status: Downloaded newer image for registry.mycompany.com/centos:latest

Docker 網絡

查看容器IP

第一種方法

docker run -d --name nginx nginx
docker inspect --format '{{ .NetworkSettings.IPAddress }}' nginx

第二種方法

docker exec -ti nginx ip add | grep global

第三種方法

docker exec -ti nginx cat /etc/hosts

端口映射

把Docker的內部端口經過端口映射的方法映射到宿主機的某一個端口，當使用 -P 標記時，Docker 會隨機映射一個 49000~49900 的端口到內部容器開放的網絡端口。

docker run -d -P nginx

docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                         NAMES
3a5ec1bc2837        nginx               "nginx -g 'daemon ..."   About an hour ago   Up About an hour    0.0.0.0:2049->80/tcp, 0.0.0.0:2048->443/tcp   adoring_pike

經過docker logs查看應用信息

[root@node1 ~]# docker logs -f adoring_pike 
172.17.0.1 - - [30/Mar/2017:15:02:40 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.29.0" "-"
10.0.7.1 - - [30/Mar/2017:15:02:47 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.29.0" "-"

-p（小寫的）則能夠指定要映射的端口，而且，在一個指定端口上只能夠綁定一個容器。支持的格式有ip:hostPort:containerPort | ip::containerPort | hostPort:containerPort。

映射到本機全部IP的 80 端口映射到容器的 80 端口

docker run -d -p 80：80 nginx

查看映射的端口

docker port adoring_pike

容器互聯

使用 --link 參數可讓容器之間安全的進行交互。
下面先建立一個新的數據庫容器。

docker run -d --name db training/postgres

而後建立一個 web 容器，並將它鏈接到 db 容器

docker run -d -P --name web --link db:db training/webapp python app.py

此時，db 容器和 web 容器創建互聯關係。

--link 參數的格式爲 --link name:alias，其中 name 是要連接的容器的名稱，alias 是這個鏈接的別名。

使用 env 命令來查看 web 容器的環境變量

[root@node1 ~]# docker run --rm --name web2 --link db:db training/webapp env
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=f2868b0479d8
DB_PORT=tcp://172.17.0.8:5432
DB_PORT_5432_TCP=tcp://172.17.0.8:5432
DB_PORT_5432_TCP_ADDR=172.17.0.8
DB_PORT_5432_TCP_PORT=5432
DB_PORT_5432_TCP_PROTO=tcp
DB_NAME=/web2/db
DB_ENV_PG_VERSION=9.3
HOME=/root

其中 DB_ 開頭的環境變量是供 web 容器鏈接 db 容器使用，前綴採用大寫的鏈接別名。

除了環境變量，Docker 還添加 host 信息到父容器的 /etc/hosts 的文件。下面是父容器 web 的 hosts 文件

[root@node1 ~]# docker run -t -i --rm --link db:db training/webapp /bin/bash
root@8299f9685894:/opt/webapp# cat /etc/hosts
127.0.0.1    localhost
::1    localhost ip6-localhost ip6-loopback
fe00::0    ip6-localnet
ff00::0    ip6-mcastprefix
ff02::1    ip6-allnodes
ff02::2    ip6-allrouters
172.17.0.8    db d65ebb9124a4
172.17.0.10    8299f9685894

docker的網絡模式

Docker的網絡模式分爲四種

Bridge模式

當Docker進程啓動時，會在主機上建立一個名爲docker0的虛擬網橋，此主機上啓動的Docker容器會鏈接到這個虛擬網橋上。虛擬網橋的工做方式和物理交換機相似，這樣主機上的全部容器就經過交換機連在了一個二層網絡中。

從docker0子網中分配一個IP給容器使用，並設置docker0的IP地址爲容器的默認網關。在主機上建立一對虛擬網卡veth pair設備，Docker將veth pair設備的一端放在新建立的容器中，並命名爲eth0（容器的網卡），另外一端放在主機中，以vethxxx這樣相似的名字命名，並將這個網絡設備加入到docker0網橋中。能夠經過brctl show命令查看。

bridge模式是docker的默認網絡模式，不寫--net參數，就是bridge模式。使用docker run -p時，docker實際是在iptables作了DNAT規則，實現端口轉發功能。可使用iptables -t nat -vnL查看。

bridge模式以下圖所示：

演示：

docker run -tid --net=bridge --name docker_bri1 ubuntu-base:v3
docker run -tid --net=bridge --name docker_bri2 ubuntu-base:v3

brctl show
docker exec -ti docker_bri1 /bin/bash
docker exec -ti docker_bri1 /bin/bash

ifconfig –a
route –n

Host模式

若是啓動容器的時候使用host模式，那麼這個容器將不會得到一個獨立的Network Namespace，而是和宿主機共用一個Network Namespace。容器將不會虛擬出本身的網卡，配置本身的IP等，而是使用宿主機的IP和端口。可是，容器的其餘方面，如文件系統、進程列表等仍是和宿主機隔離的。
Host模式以下圖所示：

Container模式

這個模式指定新建立的容器和已經存在的一個容器共享一個 Network Namespace，而不是和宿主機共享。新建立的容器不會建立本身的網卡，配置本身的 IP，而是和一個指定的容器共享 IP、端口範圍等。一樣，兩個容器除了網絡方面，其餘的如文件系統、進程列表等仍是隔離的。兩個容器的進程能夠經過 lo 網卡設備通訊。
Container模式示意圖：

None模式

使用none模式，Docker容器擁有本身的Network Namespace，可是，並不爲Docker容器進行任何網絡配置。也就是說，這個Docker容器沒有網卡、IP、路由等信息。須要咱們本身爲Docker容器添加網卡、配置IP等。

Docker網絡設置

配置 DNS

在docker run時使用如下參數：

參數	說明
-h HOSTNAME or --hostname=HOSTNAME	設定容器的主機名，它會被寫到容器內的 /etc/hostname 和/etc/hosts。但它在容器外部看不到，既不會在 docker ps 中顯示，也不會在其餘的容器的/etc/hosts 看到。
--link=CONTAINER_NAME:ALIAS	選項會在建立容器的時候，添加一個其餘容器的主機名到 /etc/hosts 文件中，讓新容器的進程可使用主機名 ALIAS 就能夠鏈接它。
--dns=IP_ADDRESS	添加 DNS 服務器到容器的 /etc/resolv.conf 中，讓容器用這個服務器來解析全部不在 /etc/hosts 中的主機名。
--dns-search=DOMAIN	設定容器的搜索域，當設定搜索域爲 .example.com 時，在搜索一個名爲 host 的主機時，DNS 不只搜索host，還會搜索 host.example.com。 注意：若是沒有上述最後 2 個選項，Docker 會默認用主機上的 /etc/resolv.conf 來配置容器。

容器訪問控制

容器訪問外部網絡

容器要想訪問外部網絡，須要本地系統的轉發支持。在Linux 系統中，檢查轉發是否打開。

sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 1

容器之間訪問

容器之間相互訪問，須要兩方面的支持。

• 容器的網絡拓撲是否已經互聯。默認狀況下，全部容器都會被鏈接到 docker0 網橋上。
• 本地系統的防火牆軟件 -- iptables 是否容許經過。

訪問全部端口

當啓動 Docker 服務時候，默認會添加一條轉發策略到 iptables 的 FORWARD 鏈上。策略爲經過（ACCEPT）仍是禁止（DROP）取決於配置 --icc=true（缺省值）仍是 --icc=false。固然，若是手動指定 --iptables=false 則不會添加 iptables 規則。

可見，默認狀況下，不一樣容器之間是容許網絡互通的。若是爲了安全考慮，能夠在docker服務修改/usr/lib/systemd/system/docker.service啓動時添加--icc=false。

訪問指定端口

在經過 -icc=false 關閉網絡訪問後，能夠經過 --link=CONTAINER_NAME:ALIAS 選項來訪問容器的開放端口。

例如，在啓動 Docker 服務時，能夠同時使用 --icc=false --iptables=true 參數來關閉容許相互的網絡訪問，並讓 Docker 能夠修改系統中的 iptables 規則。

此時，系統中的 iptables 規則多是相似

iptables -nL
...
Chain FORWARD (policy ACCEPT)
target     prot opt source               destination
DROP       all  --  0.0.0.0/0            0.0.0.0/0
...

以後，啓動容器（docker run）時使用 --link=CONTAINER_NAME:ALIAS 選項。Docker 會在 iptable中爲 兩個容器分別添加一條 ACCEPT 規則，容許相互訪問開放的端口（取決於 Dockerfile 中的 EXPOSE 行）。

當添加了 --link=CONTAINER_NAME:ALIAS 選項後，添加了 iptables 規則。

iptables -nL
...
Chain FORWARD (policy ACCEPT)
target     prot opt source               destination
ACCEPT     tcp  --  172.17.0.2           172.17.0.3           tcp spt:80
ACCEPT     tcp  --  172.17.0.3           172.17.0.2           tcp dpt:80
DROP       all  --  0.0.0.0/0            0.0.0.0/0

注意：--link=CONTAINER_NAME:ALIAS 中的 CONTAINER_NAME 目前必須是 Docker 分配的名字，或使用 --name 參數指定的名字。主機名則不會被識別。

配置 docker0 網橋

配置docekr服務的啓動參數

• --bip=CIDR -- IP 地址加掩碼格式，例如 192.168.1.0/24
• --mtu=BYTES -- 覆蓋默認的 Docker mtu 配置

sed -ri  's@(ExecStart=.*)@\1 --bip=192.168.1.100/24 --mtu=1500@g' /usr/lib/systemd/system/docker.service
systemctl daemon-reload
systemctl start docker

自定義網橋

除了默認的 docker0 網橋，用戶也能夠指定網橋來鏈接各個容器。

在啓動 Docker 服務的時候，使用 -b BRIDGE或--bridge=BRIDGE 來指定使用的網橋。

若是服務已經運行，那須要先中止服務，並刪除舊的網橋。

systemctl stop docker
ip link set dev docker0 down
brctl delbr docker0

而後建立一個網橋 bridge0。

brctl addbr bridge0
ip addr add 192.168.10.10/24 dev bridge0
ip link set dev bridge0 up

查看確認網橋建立並啓動。

[root@node1 ~]# ip addr show bridge0
4: bridge0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UNKNOWN
    link/ether 66:8c:82:ec:4e:73 brd ff:ff:ff:ff:ff:ff
    inet 192.168.10.10/24 scope global bridge0
       valid_lft forever preferred_lft forever

配置 Docker 服務，默認橋接到建立的網橋上。

sed -ri  's@(ExecStart=.*)@\1 -b bridge0@g' /usr/lib/systemd/system/docker.service 
systemctl daemon-reload
systemctl start docker

啓動 Docker 服務。 新建一個容器，能夠看到它已經橋接到了 bridge0 上。

能夠繼續用 brctl show 命令查看橋接的信息。另外，在容器中可使用 ip addr 和 ip route 命令來查看 IP 地址配置和路由信息。

[root@node1 ~]# docker run -dit centos /bin/bash
4d50cfe3a998a8597020a608d4713e3581094c9058425a4bc0652c934614713e
[root@node1 ~]# brctl show
bridge name    bridge id        STP enabled    interfaces
bridge0        8000.b6e3d8e984c5    no        vethe468bd3

建立一個點到點鏈接

默認狀況下，Docker 會將全部容器鏈接到由 docker0 提供的虛擬子網中。

用戶有時候須要兩個容器之間能夠直連通訊，而不用經過主機網橋進行橋接。
解決辦法很簡單：建立一對 peer 接口，分別放到兩個容器中，配置成點到點鏈路類型便可。

首先啓動 2 個容器：

docker run -dit --rm --net=none  --name test1 centos /bin/bash
docker run -dit --rm  --net=none --name test2 centos /bin/bash

找到進程號，而後建立網絡命名空間的跟蹤文件。

[root@node1 ~]# docker inspect -f '{{.State.Pid}}' test1
6006
[root@node1 ~]# docker inspect -f '{{.State.Pid}}' test2
6058
mkdir -p /var/run/netns
ln -s /proc/6006/ns/net /var/run/netns/6058
ln -s /proc/6058/ns/net /var/run/netns/6006

建立一對 peer 接口，而後配置路由

ip link add A type veth peer name B

ip link set A netns 6006
ip netns exec 6006 ip addr add 10.1.1.1/32 dev A
ip netns exec 6006 ip link set A up
ip netns exec 6006 ip route add 10.1.1.2/32 dev A

ip link set B netns 6058
ip netns exec 6058 ip addr add 10.1.1.2/32 dev B
ip netns exec 6058 ip link set B up
ip netns exec 6058 ip route add 10.1.1.1/32 dev B

如今這 2 個容器就能夠相互 ping 通，併成功創建鏈接。點到點鏈路不須要子網和子網掩碼。

此外，也能夠不指定 --net=none 來建立點到點鏈路。這樣容器還能夠經過原先的網絡來通訊。

利用相似的辦法，能夠建立一個只跟主機通訊的容器。可是通常狀況下，更推薦使用 --icc=false 來關閉容器之間的通訊。

Docker跨主機容器互聯

pipework

編輯本身的ifcfg-enoxxx網卡

vim /etc/sysconfig/network-scripts/ifcfg-eno16777728
TYPE="Ethernet"
DEVICE="eno16777728"
ONBOOT="yes"
BRIDGE=br0

編輯br0

vim /etc/sysconfig/network-scripts/ifcfg-br0
TYPE=Bridge
BOOTPROTO=static
IPADDR=10.0.7.1
NETMASK=255.255.0.0
GATEWAY=10.0.0.2
DNS1=10.0.0.2
NAME=br0
ONBOOT=yes
DEVICE=br0

安裝

git clone https://github.com/jpetazzo/pipework.git
cp pipework/pipework /usr/bin/

啓動docker

pipework br0 $(docker run -d -it --net=none  centos /bin/bash) 10.0.7.200/16@10.0.0.2

另外一臺主機

pipework br0 $(docker run -d -it --net=none  centos /bin/bash) 10.0.7.201/16@10.0.0.2

重啓容器後須要再次指定

pipework br0 elegant_jepsen  10.0.0.200/16@10.0.0.2

flannel

在kubernetes中有提到。

使用Supervisor來管理進程

Docker 容器在啓動的時候開啓單個進程，若是須要在一個服務器上開啓多個服務，最簡單的就是把多個啓動命令放到一個啓動腳本里面，啓動的時候直接啓動這個腳本，另外就是安裝進程管理工具。

咱們演示一下如何同時使用 ssh 和 apache 服務。

建立dockerfile

[root@node1 ~]# mkdir httpd && cd httpd
[root@node1 httpd]# cat Dockerfile
FROM centos
MAINTAINER  admin@test.com
RUN yum -y install epel-release
RUN yum -y install openssh-server openssh openssh-clients httpd supervisor
RUN mkdir -p /var/run/sshd &&\
    mkdir -p /var/log/supervisor &&\
    #centos鏡像sshd遠程鏈接直接斷開解決辦法
    sed -i  's@session    required     pam_loginuid.so@#&@g' /etc/pam.d/sshd &&\
    /usr/bin/ssh-keygen -t ed25519 -f /etc/ssh/ssh_host_ed25519_key -N '' &&\
    /usr/bin/ssh-keygen -f /etc/ssh/ssh_host_rsa_key &&\
    /usr/bin/ssh-keygen -t dsa -f /etc/ssh/ssh_host_dsa_key &&\
    echo "123456"|passwd root --stdin
COPY supervisord.conf /etc/supervisord.conf
EXPOSE 22 80
CMD ["/usr/bin/supervisord"]

建立supervisor.conf

[root@node1 httpd]# cat supervisord.conf
#配置supervisord，使用 nodaemon 參數來運行
[supervisord]
nodaemon=true

#啓動ssh，
[program:sshd]
command=/usr/sbin/sshd -D
#啓動httpd，
[program:httpd]
command=/usr/sbin/httpd

建立鏡像

docker build -t test/supervisord .

啓動 supervisor 容器

docker run -p 22 -p 80 -t -i test/supervisord

Docker Harbor

Harbor 是一個企業級的 Docker Registry，能夠實現 images 的私有存儲和日誌統計權限控制等功能，並支持建立多項目(Harbor 提出的概念)，基於官方 Registry V2 實現。

安裝docker

tee -a /etc/sysctl.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl -p
tee /etc/yum.repos.d/docker.repo <<-'EOF'
[dockerrepo]
name=Docker Repository
baseurl=https://mirrors.tuna.tsinghua.edu.cn/docker/yum/repo/centos7/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.tuna.tsinghua.edu.cn/docker/yum/gpg
EOF
yum -y install  docker-engine
systemctl enable docker
systemctl start docker
sed -i "s|ExecStart=/usr/bin/dockerd|ExecStart=/usr/bin/dockerd --registry-mirror=https://fz5yth0r.mirror.aliyuncs.com|g" /usr/lib/systemd/system/docker.service
systemctl daemon-reload
systemctl restart docker

安裝docker-compose

curl -L https://github.com/docker/compose/releases/download/1.7.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

下載源代碼

wget https://github.com/vmware/harbor/releases/download/v1.1.1-rc1/harbor-online-installer-v1.1.1-rc1.tgz
tar  xf harbor-online-installer-v1.1.1-rc1.tgz

配置ssl，參考上面的registry

touch /etc/pki/CA/{index.txt,serial}
echo 01 > /etc/pki/CA/serial
(umask 077;openssl genrsa -out  /etc/pki/CA/private/cakey.pem 2048)
openssl req -new -x509 -key  /etc/pki/CA/private/cakey.pem -out /etc/pki/CA/cacert.pem -days 3650
#填寫的信息
Country Name (2 letter code) [XX]:CN
State or Province Name (full name) []:Beijing
Locality Name (eg, city) [Default City]:Beijing
Organization Name (eg, company) [Default Company Ltd]:harbor 
Organizational Unit Name (eg, section) []:ops
Common Name (eg, your name or your server's hostname) []:harbor.com
Email Address []:admin@harbor.com

cat /etc/pki/CA/cacert.pem >> /etc/pki/tls/certs/ca-bundle.crt
mkdir -p /root/cert
(umask 077;openssl genrsa -out /root/cert/harbor.key 2048)
openssl req -new -key /root/cert/harbor.key -out /root/cert/harbor.csr
#和上面的信息同樣
openssl ca -in /root/cert/harbor.csr -out /root/cert/harbor.crt -days 3650

#docker建立根證書
mkdir -p /etc/docker/certs.d/harbor.com
cp /etc/pki/CA/cacert.pem /etc/docker/certs.d/harbor.com/ca.crt
systemctl daemon-reload
systemctl restart docker

修改配置文件

vim harbor/harbor.cfg

hostname = harbor.com
ui_url_protocol = https
db_password = 123456
ssl_cert = /root/cert/harbor.crt
ssl_cert_key = /root/cert/harbor.key
harbor_admin_password = 123456

安裝

cd harbor
./install.sh

經常使用操做，在harbor目錄下

#啓動
docker-compose start
#關閉
docker-compose stop
#修改配置文件步驟
docker-compose down -v
vim harbor.cfg
./prepare 
docker-compose up -d
docker-compose start

修改hosts

vim /etc/hosts
10.0.7.1 harbor.com

登錄測試

[root@node1 harbor]# docker login harbor.com
Username: admin
Password: 
Login Succeeded

其餘主機測試

#建立一個文件夾
mkdir -p /etc/docker/certs.d/harbor.com
#把證書複製過去
scp /etc/docker/certs.d/harbor.com/ca.crt 10.0.7.2:/etc/docker/certs.d/harbor.com/ca.crt
systemctl daemon-reload
systemctl restart docker

vim /etc/hosts
10.0.7.1 harbor.com


[root@node2 ~]# docker login harbor.com
Username: admin
Password: 
Login Succeeded

windows測試

若是使用http，使用如下配置

vim harbor/harbor.cfg
ui_url_protocol = http

修改docker啓動參數，添加
--insecure-registry

上傳鏡像測試

docker pull centos
docker tag centos harbor.com/library/centos
docker push harbor.com/library/centos

添加系統用戶

爲項目添加用戶

• 項目管理員和開發人員能夠push 和pull鏡像，
• 訪客只能pull鏡像。

使用test做爲開發人員測試

[root@node2 ~]# docker login harbor.com
Username (admin): test
Password: 
Login Succeeded

docker pull busybox
docker tag centos harbor.com/library/busybox
docker push harbor.com/library/busybox

看日誌爲test提交了一個busybox鏡像