docker之經常使用命令、自定製鏡像、公(私)倉庫的上傳和下載

1、docker入門

一、介紹

1. 什麼是docker
Docker 最初是 daoCloud 公司創始人 Solomon Hykes 在法國期間發起的一個公司內部項目，於 2013 年 3 月以 Apache 2.0 受權協議開源，主要項目代碼在 GitHub 上進行維護。
Docker 使用 Google 公司推出的 Go 語言 進行開發實現。
docker是linux容器的一種封裝，提供簡單易用的容器使用接口。它是最流行的Linux容器解決方案。
docker的接口至關簡單，用戶能夠方便的建立、銷燬容器。
docker將應用程序與程序的依賴，打包在一個文件裏面。運行這個文件就會生成一個虛擬容器。
程序運行在虛擬容器裏，如同在真實物理機上運行同樣，有了docker，就不用擔憂環境問題了

KVM, Virtualbox, Vmware是虛擬出機器，讓每一個實例看到一個單獨的機器；而Docker是虛擬出操做系統，實現應用之間的隔離，讓各個應用以爲本身有一個本身的操做系統，並且彼此之間隔離。

2.docker應用場景
web應用的自動化打包和發佈
自動化測試和持續集成、發佈
在服務型環境中部署和調整數據庫或其餘應用

 

二、爲何要用docker

首先要知道在實際中，咱們如何解決項目部署的環境配置的問題呢？

1. 解決方案1,使用虛擬機
使用vmware的克隆功能，vmware支持一個模板克隆
首先準備一個vmware系統模板，裝好一些必要的環境，例如：python3 mysql redis nginx等等，
而後基於這個模板，克隆生成新的系統，在新的系統上能夠根據項目須要的繼續配置不一樣的環境，
也就是，基於同一個鏡像，同一個系統模板，能夠生成 N 個系統實例。

可是可是虛擬化也是有侷限性的，每個虛擬機都是一個完整的操做系統，要分配系統資源，虛擬機多道必定程度時，操做系統自己資源也就消耗殆盡，或者說必須擴容

虛擬機的缺點：
1,資源佔用多
虛擬機會獨佔一部份內存和硬盤空間。它運行的時候，其餘程序就不能使用這些資源了。哪怕虛擬機裏面的應用程序，真正使用的內存只有 1MB，虛擬機依然須要幾百 MB 的內存才能運行。

2,冗餘步驟多
虛擬機是完整的操做系統，一些系統級別的操做步驟，每每沒法跳過，好比用戶登陸。

3,啓動慢
啓動操做系統須要多久，啓動虛擬機就須要多久。可能要等幾分鐘，應用程序才能真正運行。

 

2. 解決方案2，使用linux容器
Linux容器不是模擬一個完整的操做系統，而是對進程進行隔離。在正常進程的外面套了一個保護層，對於容器裏面進程來講，它接觸的資源都是虛擬的，從而實現和底層系統的隔離。

docker是linux的一種容器。

優勢
1,啓動快
容器裏面的應用，直接就是底層系統的一個進程，而不是虛擬機內部的進程。因此，啓動容器至關於啓動本機的一個進程，而不是啓動一個操做系統，速度就快不少。

2,資源佔用少
容器只佔用須要的資源，不佔用那些沒有用到的資源；虛擬機因爲是完整的操做系統，不可避免要佔用全部資源。另外，多個容器能夠共享資源，虛擬機都是獨享資源。

3,體積小
容器只要包含用到的組件便可，而虛擬機是整個操做系統的打包，因此容器文件比虛擬機文件要小不少。
總之，容器有點像輕量級的虛擬機，可以提供虛擬化的環境，可是成本開銷小得多。

 

三、docker與傳統虛擬機對比

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

 

四、虛擬機和docker容器的架構

1. 虛擬機

 

2. 容器

 

3. 虛擬機+容器

 

docker的每一個容器都至關於一個微型的操做系統，它佔用的資源很是少，
所以在一個系統上能夠開啓很是多的docker實例。

 

2、Docker的初步使用

一、docker三大概念

鏡像 image
容器 container
倉庫 repository
docker整個生命週期就是這三個概念

1. docker鏡像(image)
Docker鏡像就是一個只讀的模板。
例如：一個鏡像能夠包含一個完整的CentOS操做系統環境，裏面僅安裝了Apache或用戶須要的其餘應用程序。
就至關於咱們之前買的那些dvd裝機的碟，你用這個碟能夠給你的電腦裝上win7 10 等系統，系統自帶了一些軟件，
暴風影音，QQ等，而後裝好系統後，咱們須要什麼，咱們還能本身下載，好比LOL、跑跑卡丁車之類的。

有了鏡像後，就能夠用鏡像來建立Docker容器。
Docker提供了一個很簡單的機制來建立鏡像或者更新現有的鏡像，用戶甚至能夠直接從其餘人那裏下載一個已經作好的鏡像來直接使用。

鏡像的分層存儲
由於鏡像包含完整的root文件系統，體積是很是龐大的，所以docker在設計時按照Union FS的技術，將其設計爲分層存儲的架構。
鏡像不是ISO那種完整的打包文件，鏡像只是一個虛擬的概念，他不是一個完整的文件，而是由一組文件組成，或者多組文件系統聯合組成


2. docker容器(container)
image和container的關係，就像面向對象程序設計中的 類和實例同樣，鏡像是靜態的類（class），容器是鏡像運行時的實體（實例化的對象object）

Docker利用容器來運行應用。

容器是從鏡像建立的運行實例。它能夠被啓動、開始、中止、刪除。每一個容器都是相互隔離的，保證安全的平臺。

能夠把容器看作是一個簡易版的Linux環境（包括root用戶權限、進程空間、用戶空間和網絡空間等）和運行在其中的應用程序。

鏡像
容器實例1=鏡像()
容器實例2=鏡像()
容器實例3=鏡像()
容器實例4=鏡像()
容器實例5=鏡像()

注意：鏡像是隻讀的，容器在啓動的時候建立一層可寫層做爲最上層。


3. docker倉庫(repository)
倉庫是集中存放鏡像文件的場所。有時候把倉庫和倉庫註冊服務器（Registry）混爲一談，並不嚴格區分。
實際上，倉庫註冊服務器上每每存放着多個倉庫，每一個倉庫中又包含了多個鏡像，每一個鏡像有不一樣的標籤(tag)。

倉庫分爲公開倉庫(Public)和私有倉庫(Private)兩種形式。

最大的公開倉庫是Docker Hub，存放了數量龐大的鏡像供用戶下載。國內的公開倉庫包括Docker Pool等，能夠提供大陸用戶更穩定快讀的訪問。

當用戶建立了本身的鏡像以後就可使用push命令將它上傳到公有或者私有倉庫，這樣下載在另一臺機器上使用這個鏡像時候，只需須要從倉庫上pull下來就能夠了。

注意：Docker倉庫的概念跟Git相似，註冊服務器能夠理解爲GitHub這樣的託管服務。

 

二、CentOS安裝docker

官方提供的安裝方式：
https://docs.docker.com/install/linux/docker-ce/centos/#upgrade-docker-after-using-the-convenience-script

 

總結官方教程以下

1.卸載舊版本
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine

2.設置存儲庫
sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

3.安裝docker社區版
sudo yum install docker-ce

4.啓動關閉docker
systemctl start/stop/restart/status docker

5.查看docker版本
docker version 

 

三、Docker鏡像加速器

修改docker的鏡像加速器,daocloud公司推出的加速工具
1.一句命令生成docker加速地址
curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io

2.好像有一個坑，請修改配置文件 /etc/docker/daemon.json
改爲以下配置便可(默認在最後有個逗號，去掉便可，若是沒有，請忽略如下步驟)
{"registry-mirrors": ["http://f1361db2.m.daocloud.io"]}

3.重啓docker
systemctl restart docker 

 

四、注意

docker容器必須有後臺進程在運行，若是docker容器內沒有任務在運行中，容器就退出
docker容器必須有後臺進程在運行，若是docker容器內沒有任務在運行中，容器就退出
docker容器必須有後臺進程在運行，若是docker容器內沒有任務在運行中，容器就退出

 

五、docker run

docker run ：建立一個新的容器並運行一個命令

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

OPTIONS說明：

• -d: 後臺運行容器，並返回容器ID；

• -i: 以交互模式運行容器，一般與 -t 同時使用；

• -t: 爲容器從新分配一個僞輸入終端，一般與 -i 同時使用；
• --name="zbj": 爲容器指定一個名稱；
• -a stdin: 指定標準輸入輸出內容類型，可選 STDIN/STDOUT/STDERR 三項；

• -P: 隨機端口映射，容器內部端口隨機映射到主機的高端口

• -p: 指定端口映射，格式爲：主機(宿主)端口:容器端口

• --dns 8.8.8.8: 指定容器使用的DNS服務器，默認和宿主一致；

• --dns-search example.com: 指定容器DNS搜索域名，默認和宿主一致；

• -h "mars": 指定容器的hostname；

• -e username="ritchie": 設置環境變量；

• --env-file=[]: 從指定文件讀入環境變量；

• --cpuset="0-2" or --cpuset="0,1,2": 綁定容器到指定CPU運行；

• -m :設置容器使用內存最大值；

• --net="bridge": 指定容器的網絡鏈接類型，支持 bridge/host/none/container:<name|id> 四種類型；

• --link=[]: 添加連接到另外一個容器；

• --expose=[]: 開放一個端口或一組端口；

• --volume , -v: 綁定一個卷

實例
# 使用docker鏡像centos以 後臺模式 啓動一個容器, 並將容器命名爲mycentos。
docker run --name mycentos -d centos

# 使用鏡像centos以 後臺模式 啓動一個容器,並將容器的80端口映射到主機隨機端口。
docker run -P -d centos

# 使用鏡像 centos，以 後臺模式 啓動一個容器,將容器的 80 端口映射到主機的 80 端口,主機的目錄 /data 映射到容器的 /data。
docker run -p 80:80 -v /data:/data -d centos

# 綁定容器的 8080 端口，並將其映射到本地主機 127.0.0.1 的 80 端口上。
$ docker run -p 127.0.0.1:80:8080/tcp ubuntu bash

# 使用鏡像centos以 交互模式啓動一個容器,在容器內執行/bin/bash命令。
root@aliyunzbj:~$ docker run -it centos /bin/bash
[root@44026fe3420e /]# 

docker start 容器id  # 啓動這個容器
docker stop  容器id  # 中止這個容器的運行
docker kill  容器id  # 中止這個容器的運行

docker rm 容器id  # 刪除這個容器

 

六、docker的基本示例

1. 示例1

docker search  hello-docker  # 搜索docker鏡像 ，就是去 docker hub搜索 hello-docker

docker pull hello-world        # 下載公網的，docker鏡像

docker  image ls  # 查看本地的鏡像有哪些
docker  images     # 這兩條命令同樣的,docker進行了不少的命令升級，不用慌

docker run  hello-world   # 運行一個docker鏡像，產生一個容器實例

docker  container  ls  # 列出全部正在運行的容器(由於hello world一跑完就退出了，一退出，容器也就退出了)

docker  ps  -a    # 列出全部曾經運行過的容器記錄，以及正在運行的容器記錄
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS
容器ID                鏡像                命令                建立時間                 狀態

 

2. 示例2

建立一個可交互的容器

"""
docker run xxx : 建立一個新的容器
docker exec xxx : 進入一個已存在的容器
"""

# 查找centos倉庫
docker search centos

# 下載cnetos鏡像
docker pull  centos

# 建立一個新的容器，且以交互式的方式進入容器
docker run -itd centos /bin/bash

# 查看容器ID或者名字
docker ps -a
# 結果
CONTAINER ID        IMAGE               COMMAND             CREATED                STATUS                     NAMES
b367c2c29aac        centos            "/bin/bash"        6 seconds ago     Exited (0) 2 seconds ago     ecstatic_chebyshev

# 啓動容器
docker start ecstatic_chebyshev
或者
docker start b367c2c29aac

# 容器是有本身的微型操做系統的。微型linux
docker exec -it  b367c2c29aac  /bin/bash
    exec  # 進入容器的參數
    -i    # 交互式的操做容器
    -t    # 開啓一個terminel終端，用於和linux交互
    b367c2c29aac   # docker容器的id
    /bin/bash  # 指定docker容器，用shell解釋器交互
    
或者
docker exec -it  ecstatic_chebyshev  /bin/bash

# 退出容器
exit

 

3.示例3

# 運行一個在後臺的任務
docker run -d centos /bin/sh -c "while true;do echo hello-docker; sleep 1;done"
    -d        # 後臺運行容器
    /bin/sh   # 指定使用centos的bash解釋器
    -c        # 運行一段shell命令
    "while true;do echo hello-docker; sleep 1;done"   # 在linux後臺，每秒中打印一個hello-docker

docker  ps  -a  # 列出全部曾經運行過的容器記錄，以及正在運行的容器記錄

docker  logs  -f  容器id  #不間斷打印容器的日誌信息 

 

3、docker命令詳解

一、參數和命令彙總

1. 參數

Options:
  --config=~/.docker              Location of client config files  #客戶端配置文件的位置

  -D, --debug=false               Enable debug mode  #啓用Debug調試模式

  -H, --host=[]                   Daemon socket(s) to connect to  #守護進程的套接字（Socket）鏈接

  -h, --help=false                Print usage  #打印使用

  -l, --log-level=info            Set the logging level  #設置日誌級別

  --tls=false                     Use TLS; implied by--tlsverify  #

  --tlscacert=~/.docker/ca.pem    Trust certs signed only by this CA  #信任證書籤名CA

  --tlscert=~/.docker/cert.pem    Path to TLS certificate file  #TLS證書文件路徑

  --tlskey=~/.docker/key.pem      Path to TLS key file  #TLS密鑰文件路徑

  --tlsverify=false               Use TLS and verify the remote  #使用TLS驗證遠程

  -v, --version=false             Print version information and quit  #打印版本信息並退出

 

2. 命令

Commands:
    attach    Attach to a running container  #當前shell下attach鏈接指定運行鏡像

    build     Build an image from a Dockerfile  #經過Dockerfile定製鏡像

    commit    Create a new image from a container's changes  #提交當前容器爲新的鏡像

    cp    Copy files/folders from a container to a HOSTDIR or to STDOUT  #從容器中拷貝指定文件或者目錄到宿主機中

    create    Create a new container  #建立一個新的容器，同run 但不啓動容器

    diff    Inspect changes on a container's filesystem  #查看docker容器變化

    events    Get real time events from the server#從docker服務獲取容器實時事件

    exec    Run a command in a running container#在已存在的容器上運行命令

    export    Export a container's filesystem as a tar archive  #導出容器的內容流做爲一個tar歸檔文件(對應import)

    history    Show the history of an image  #展現一個鏡像造成歷史

    images    List images  #列出系統當前鏡像

    import    Import the contents from a tarball to create a filesystem image  #從tar包中的內容建立一個新的文件系統映像(對應export)

    info    Display system-wide information  #顯示系統相關信息

    inspect    Return low-level information on a container or image  #查看容器詳細信息

    kill    Kill a running container  #kill指定docker容器

    load    Load an image from a tar archive or STDIN  #從一個tar包中加載一個鏡像(對應save)

    login    Register or log in to a Docker registry#註冊或者登錄一個docker源服務器

    logout    Log out from a Docker registry  #從當前Docker registry退出

    logs    Fetch the logs of a container  #輸出當前容器日誌信息

    pause    Pause all processes within a container#暫停容器

    port    List port mappings or a specific mapping for the CONTAINER  #查看映射端口對應的容器內部源端口

    ps    List containers  #列出容器列表

    pull    Pull an image or a repository from a registry  #從docker鏡像源服務器拉取指定鏡像或者庫鏡像

    push    Push an image or a repository to a registry  #推送指定鏡像或者庫鏡像至docker源服務器

    rename    Rename a container  #重命名容器

    restart    Restart a running container  #重啓運行的容器

    rm    Remove one or more containers  #移除一個或者多個容器

    rmi    Remove one or more images  #移除一個或多個鏡像(無容器使用該鏡像才能夠刪除，不然須要刪除相關容器才能夠繼續或者-f強制刪除)

    run    Run a command in a new container  #建立一個新的容器並運行一個命令

    save    Save an image(s) to a tar archive#保存一個鏡像爲一個tar包(對應load)

    search    Search the Docker Hub for images  #在docker hub中搜索鏡像

    start    Start one or more stopped containers#啓動容器

    stats    Display a live stream of container(s) resource usage statistics  #統計容器使用資源

    stop    Stop a running container  #中止容器

    tag         Tag an image into a repository  #給源中鏡像打標籤

    top       Display the running processes of a container #查看容器中運行的進程信息

    unpause    Unpause all processes within a container  #取消暫停容器

    version    Show the Docker version information#查看容器版本號

    wait         Block until a container stops, then print its exit code  #截取容器中止時的退出狀態值

 

 

二、一些經常使用的命令

0.啓動關閉docker
# 開啓/中止/重啓/查看docker狀態
systemctl start/stop/restart/status docker

# 查看docker版本
docker version 

1.搜索鏡像
docker search  hello-docker  # 搜索docker鏡像 ，就是去 docker hub搜索 hello-docker

2.下載鏡像
docker pull hello-world        # 下載公網的，docker鏡像

3.查看本地鏡像
docker  image ls  # 查看本地的鏡像有哪些
docker  images    # 這兩條命令同樣的,docker進行了不少的命令升級，不用慌

4.基於鏡像開啓新的容器
# 下載cnetos鏡像
docker pull  centos

# 運行一個docker鏡像，產生一個容器實例
docker run  hello-world
docker run  centos  # 注意：沒有鏡像的狀況下，直接run，系統會自動幫咱們去下載一個鏡像

# 建立一個新的容器，並運行在在linux後臺，每秒中打印一個hello-docker
docker run -d centos /bin/sh -c "while true;do echo hello-docker; sleep 1;done"
    -d        # 後臺運行容器
    /bin/sh   # 指定使用centos的bash解釋器
    -c        # 運行一段shell命令
    "while true;do echo hello-docker; sleep 1;done"

# 建立一個新的容器，且以交互式的方式進入容器
docker run  -it  centos  /bin/bash
    -i    # 交互式的操做容器
    -t    # 開啓一個terminel終端，用於和linux交互

# 啓動一個bash終端,容許用戶進行交互
docker run --name mydocker -it centos /bin/bash

5.查看正在運行的容器
docker  container  ls  # 列出全部正在運行的容器(由於hello world一跑完就退出了，一退出，容器也就退出了)

6.查看全部運行過的容器
docker  ps  -a    # 列出全部曾經運行過的容器記錄，以及正在運行的容器記錄
CONTAINER ID        IMAGE               COMMAND             CREATED         STATUS     NAMES
容器ID              鏡像                命令                建立時間         狀態      容器名

7.查看容器日誌
docker  logs  -f  容器id  #不間斷打印容器的日誌信息 

8.進入已有的容器
# 容器是有本身的微型操做系統的。微型linux
docker exec -it  ee0  /bin/bash
    exec  # 進入容器的參數
    -i    # 交互式的操做容器
    -t    # 開啓一個terminel終端，用於和linux交互
    ee0   # docker容器的id
    /bin/bash  # 指定docker容器，用shell解釋器交互

exit  # 退出容器terminel終端

9.開始/中止容器
docker start  容器id  # 開始運行這個容器
docker kill  容器id   # 中止這個容器的運行
docker stop  容器id   # 中止這個容器的運行
docker stop  `docker ps -aq`  # 中止全部正在運行的容器


10.刪除容器記錄
docker rm  容器id  # 刪除這個容器
docker ps -aq  # 列出全部容器記錄的id
docker rm `docker ps -aq`    #一次性刪除全部容器記錄

11.刪除鏡像(必須刪除依賴這個鏡像的容器記錄)
docker rmi 鏡像id/鏡像名
docker rmi -f 鏡像id/鏡像名  # -f 強制刪除
docker images -aq  # 列出全部本地鏡像id
docker rmi  `docker images -aq`   #一次性刪除全部本地的鏡像記錄

12.查看系統的版本信息
cat /etc/os-release  # 查看系統的版本信息(通用)
cat /etc/redhat-release  # 查看紅帽系列的系統(不是紅帽系列的系統查看不到信息)

 

4、docker一些操做

一、基於一個容器，自定製咱們的鏡像

就是你pull一個鏡像到本地，新建一個容器後，你能夠在容器內進行一些環境的配置，
而後根據這個容器，產生一個新的鏡像，那麼當你須要這套環境的時候就能夠直接使用這個新的鏡像建立容器了。

這裏只是爲了演示，下載官方的centos鏡像，建立的容器默認是沒有vim編輯器的，
咱們就給這個容器下載vim編輯器，而後造成咱們本身的鏡像。

步驟以下：

1.基於centos鏡像，建立一個容器，在容器安裝一個vim工具
# 開啓新容器，並以交互式的方式進入容器
docker run  -it  centos  /bin/bash
# 在容器空間內裝vim
yum install vim -y 

2.退出當前容器，容器因爲沒有後臺任務，當即掛掉，可是咱們能夠提交這個容器爲新的鏡像
# 退出容器
exit
# 查看以前運行的容器的id
docker -ps -a
# 提交當前容器爲新的鏡像
docker commit 容器id  造成的鏡像名
docker commit f00d48 zbj/centos-vim

3.查看已提交的鏡像記錄
docker images

4.測試
# 基於這個擁有vim的鏡像，建立新的容器
docker run -it 鏡像名/鏡像id  /bin/bash
docker run -it zbj/centos-vim /bin/bash
docker run -it 11c150 /bin/bash
# 看可否使用vim
vim
# 退出容器
exit

5.導出當前系統的鏡像文件，能夠傳輸給其餘人
docker save zbj/centos-vim  > /opt/centos-vim.tar.gz

6.查看是否生成了鏡像文件 
ls /opt

7.其餘人或者本身能夠導入這個鏡像文件
# 導入鏡像
docker load < /opt/centos-vim.tar.gz
# 查看鏡像導入狀況
docker images

 

二、讓外部能夠訪問容器(暴露端口)

0.training/webapp 這個鏡像文件生成的容器是什麼
這個做者構建webapp鏡像
    1.基於ubuntu 14.04的操做系統
    2.默認進入了/opt/webapp目錄
    3.在這個目錄下存放了Procfile  app.py  requirements.txt  tests.py
    4.經過容器內的命令，運行一個後臺程序  python  app.py 
    5.最終這個鏡像，生成了一個web容器
    6.數據掛載 
        -v  宿主機的文件夾:容器內的文件夾
        -p  端口映射  宿主機的端口:容器內的端口
    7.  docker port  82e  查看容器的端口映射關係

也就是說咱們基於這個鏡像，運行了一個flask web app


容器中能夠運行網絡應用，可是要讓外部也能夠訪問這些應用，能夠經過-p或-P參數指定端口映射。
-P  隨機映射端口到容器開放的網絡端口
-p  指定映射端口，格式：   物理機的端口:容器內暴露的端口
而後咱們經過瀏覽器訪問物理機的端口，就能夠訪問到 容器 開啓的應用


1.下載一個web應用的鏡像
docker pull training/webapp

2.隨機映射端口到容器開放的網絡端口
docker run -d -P training/webapp python app.py

3.查看物理機映射到容器的端口
docker ps -a
# 看PORTS這個參數
CONTAINER ID  ....             PORTS                  
d2bcc0c57ba1  ....   0.0.0.0:32768->5000/tcp

4. 用瀏覽器訪問
你的ip:32768

5.指定服務器的9000端口，映射到容器內的5000端口
docker run -d -p 9000:5000 training/webapp python app.py

6.用瀏覽器訪問
你的ip:9000

 

三、發佈docker鏡像到docker hub(公有的倉庫)

1.登陸docker hub倉庫，註冊一個用戶，用於存放本身的docker鏡像
網址：https://hub.docker.com/

2.在linux中登陸docker
docker login  # 輸入帳號密碼

3.修改本地鏡像的tag，推送到docker hub
注意：
    要保證image的tag是 帳戶名/倉庫名 的形式，若是鏡像tag不對，須要改一下tag,否則會說你沒有權限。

語法：
    docker tag 本地鏡像名  帳戶名/倉庫名[:TAG]

docker tag hello-world 573190041/docker-test  # 生成新的鏡像

4.推送本地鏡像到公有倉庫
語法：
    docker push 帳戶名/倉庫名:TAG  # TAG可不寫,不寫默認是latest

docker push 573190041/docker-test
docker push 573190041/docker-test:latest

5.任何人均可以隨意下載這個鏡像
# 刪除本地的鏡像，測試
docker rmi hello-world
docker rmi 573190041/docker-test
# 從公有倉庫下載
docker pull 573190041/docker-test

 

四、搭建私有docker倉庫，提交本地鏡像

上面那種鏡像倉庫是公開的，其餘人都是能夠下載的，並不安全，所以還可使用docker registry官方提供的私有倉庫

1.下載一個docker官方私有倉庫鏡像
docker pull registry

2.運行一個docker私有容器倉庫
# 私有倉庫會被建立在容器的/var/lib/registry下

docker run -d -p 5000:5000 -v /opt/data/registry:/var/lib/registry  registry
    -d  後臺運行 
    -p  端口映射  5000:5000
        把容器內的5000端口映射到物理機的5000端口
    -v  數據卷掛載  /opt/data/registry :/var/lib/registry 
        把容器內的私有倉庫/var/lib/registry映射到物理機本地的/opt/data/registry
    registry  鏡像名

3.檢查啓動的registry容器
docker ps

4.測試鏈接容器
# ping一般是用來檢查網絡是否通暢或者網絡鏈接速度的命令，而telnet是用來探測指定ip是否開放指定端口的。
yum install telnet
telnet 192.168.3.16 5000

5.修改docker的配置文件，讓他支持http方式，上傳私有鏡像
vim /etc/docker/daemon.json
寫入以下內容
{
"registry-mirrors": ["http://f1361db2.m.daocloud.io"],
"insecure-registries":["192.168.3.16:5000"]
}

6.修改docker的服務配置文件
vim /lib/systemd/system/docker.service
# 找到[service]這一代碼區域塊，寫入以下參數
[Service]
EnvironmentFile=-/etc/docker/daemon.json

7.從新加載docker服務
systemctl daemon-reload

8.重啓docker服務
注意：
    重啓docker服務，全部的容器都會掛掉
    重啓docker服務，全部的容器都會掛掉
    重啓docker服務，全部的容器都會掛掉
# 重啓docker服務
systemctl restart docker
# 查看以前運行的容器，找到registry容器的ID，重啓這個容器
docker ps -a
# 重啓registry
docker start c25

9.修改本地鏡像的tag標記，往本身的私有倉庫推送
語法：
    docker tag 鏡像名 私有倉庫地址:端口/自定義tag名

# 修改tag
docker tag 573190041/docker-test  192.168.3.16:5000/zbj

# 推到私有倉庫
docker push 192.168.3.16:5000/zbj

10.因爲docker registry沒有web項目，可是提供了API數據
官網教程：https://docs.docker.com/registry/spec/api/#listing-repositories

linux輸入命令：curl http://192.168.3.16:5000/v2/_catalog
或者瀏覽器訪問：http://192.168.3.16:5000/v2/_catalog
可查看到你上傳的私有鏡像

11.刪除本地鏡像，下載私有倉庫的鏡像
docker pull 192.168.3.16:5000/zbj

 

五、Dockerfile介紹

鏡像的定製就是定製每一層所添加的配置、文件。若是能夠把每一層修改、安裝、構建、操做的命令都寫入到一個腳本，用腳原本構建、定製鏡像，這個腳本就是dockerfile。
Dockerfile 是一個文本文件，其內包含了一條條的指令(Instruction)，每一條指令 構建一層，所以每一條指令的內容，就是描述該層應當如何構建。

 1. 初級

FROM centos # 使用base image基礎鏡像，儘可能使用官方的image做爲base image
FROM ubuntu:14.04 # 帶有tag的base image


LABEL version=「1.0」 # 容器元信息，幫助信息，Metadata，相似於代碼註釋
LABEL maintainer=「zzz"


WORKDIR /root # 至關於linux的cd命令，改變目錄，儘可能使用絕對路徑！！！不要用RUN cd
WORKDIR /test # 若是沒有就自動建立

RUN touch a.txt  # RUN是萬能命令，RUN後面跟你要操做的命令。建立a.txt文件
RUN pwd     # 打印當前絕對路徑

ADD and COPY 
ADD hello /  # 把本地文件添加到鏡像中，把本地的hello可執行文件拷貝到鏡像的/目錄
ADD test.tar.gz /  # ADD自帶解壓功能，添加到根目錄並解壓

WORKDIR /root
ADD test.tar.gz test/  # 進入/root/ 添加test.tar.gz壓縮包到到test目錄下，並解壓
COPY test.tar.gz test/  # 等同於上述ADD效果，可是不會解壓test.tar.gz

ADD與COPY
   -優先使用COPY命令
   -ADD除了COPY功能還有解壓功能
添加遠程文件/目錄使用curl或wget

ENV # 環境變量，儘量使用ENV增長可維護性
ENV MYSQL_VERSION 5.6 #設置一個mysql常量
RUN yum install -y mysql-server=「${MYSQL_VERSION}」 

 

2. 中級

VOLUME and EXPOSE 
存儲和網絡

RUN and CMD and ENTRYPOINT
RUN：執行命令並建立新的Image Layer
CMD：設置容器啓動後默認執行的命令和參數
ENTRYPOINT：設置容器啓動時運行的命令

Shell格式
RUN yum install -y vim
CMD echo 」hello docker」
ENTRYPOINT echo 「hello docker」

Exec格式
RUN [「apt-get」,」install」,」-y」,」vim」]
CMD [「/bin/echo」,」hello docker」]
ENTRYPOINT [「/bin/echo」,」hello docker」]


經過shell格式去運行命令，會讀取$name指令，而exec格式是僅僅的執行一個命令，而不是shell指令
FROM centos
ENV name Docker
ENTRYPOINT [「/bin/echo」,」hello $name」]#這個僅僅是執行echo命令，讀取不了shell變量
ENTRYPOINT  [「/bin/bash」,」-c」,」echo hello $name"]


CMD
容器啓動時默認執行的命令
若是docker run指定了其餘命令(docker run -it [image] /bin/bash )，CMD命令被忽略
若是定義多個CMD，只有最後一個執行


ENTRYPOINT
讓容器以應用程序或服務形式運行
不會被忽略，必定會執行
最佳實踐：寫一個shell腳本做爲entrypoint
COPY docker-entrypoint.sh /usr/local/bin
ENTRYPOINT [「docker-entrypoint.sh]
EXPOSE 27017
CMD [「mongod」]


FROm centos
ENV name Docker
#CMD ["/bin/bash","-c","echo hello $name"]
ENTRYPOINT ["/bin/bash","-c","echo hello $name」]

 

六、利用Dockerfile自定製鏡像

1.建立工做目錄，並準備一段flask代碼
mkdir -p /opt/dockertest/
cd /opt/dockertest/

touch flasktest.py
# 內容以下
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
    return "you are a good 8"
if __name__=="__main__":
    app.run(host='0.0.0.0',port=8080)

 

2.構建Dockerfile的思路
    1,指引一個基礎的系統鏡像centos 
    2,定義做者標籤
    3,解決環境依賴關係，安裝python-setuptools  # 就是下載python的包管理工具
    4,安裝flask模塊  easy_install  flask 
    5,準備代碼文件到容器中   COPY  flasktest.py   /opt/ 
    6,切換到/opt目錄下 workdir  /opt 
    7,暴露端口
    8,運行代碼  python flasktest.py 
    
3.Dockerfile內容以下
touch Dockerfile  # Dockerfile文件必須叫這個
內容以下：
FROM centos
LABEL maintainer="自定製個人鏡像"
RUN yum install python-setuptools -y 
RUN  easy_install flask 
COPY  flasktest.py   /opt/
WORKDIR /opt
EXPOSE 8080  
CMD ["python","flasktest.py"]

4.構建鏡像文件，找到當前目錄的Dockerfile，開始構建
docker build -t  zbj/flask-web  /opt/dockertest
    
5.基於這個鏡像，生成容器實例,映射一個端口供外部訪問
docker images  # 查看生成了鏡像沒有
docker run -d -p  8888:8080  zbj/flask-web

6.測試
# 檢查運行的容器
docker container ls

# 用瀏覽器訪問 
你的服務器ip:8888

7.推送這個鏡像到私有倉庫
docker tag  zbj/flask-web  192.168.3.16:5000/zbj-flaskweb
docker push 192.168.3.16:5000/zbj-flaskweb