什么是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鏡像

總結

以上是生活随笔為你收集整理的Docker学习笔记，从原理到实践的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。