Docker學習總結

什麼是Docker

一種軟件容器

能夠快速的搭建、配置、複製軟件的運行環境

爲何要用Docker

• 一次配置，處處運行，解決軟件運行環境不一致的問題，可以提供軟件完整的運行環境，提升部署效率

• 遷移方便，能夠很輕易的將在一個平臺上運行的應用，遷移到另外一個平臺上，而不用擔憂運行環境的變化致使應用沒法正常運行的狀況。

• 啓動時間快，大大的節約了開發、測試、部署的時間。

• 具備良好的隔離性，避免軟件的相互影響

• 彈性伸縮，快速擴展，善於處理集中爆發的服務器使用壓力

• 持續交付和部署，能夠經過定製應用鏡像來實現持續集成、持續交付、部署

Docker的簡單使用：Mysql的安裝和使用（CentOS）

docker官方文檔

1. 安裝Docker

   1. 安裝系統工具

      1 sudo yum install -y yum-utils device-mapper-persistent-data lvm2

   2. 添加軟件源信息

      1 sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

   3. 更新yum緩存

      1 sudo yum makecache fast

   4. 安裝Docker

      1 ## 中途安裝過程當中停下了.看到提示Y/N就輸入 Y
      2 sudo yum -y install docker-ce

   5. 啓動Docker服務

      1 sudo systemctl start docker

2. 獲取Mysql

   1. 搜索mysql鏡像

      1  docker search mysql

   2. 下載須要的鏡像

      1 docker pull mysql:5.7

3. 運行Mysql

   1  docker run -p 3306:3306 --name dockermysql -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

4. 配置Mysql

   查看啓動的Mysql容器的編號

   1 docker ps

   進入MySQL容器（進入的爲容器的根目錄，可使用ls命令查看目錄）

   1 docker exec -it 容器編號 /bin/bash

   進入容器後，可以使用Linux命令進行操做（可能存在部分命令沒法使用的狀況）

5. 使用Mysql

   1 mysql -u用戶名 -p

   輸入密碼以後便可進入操做mysql，輸入help查看提示，\q退出（僅退出MySQL，還在容器內部）

Docker的安裝（CentOS）

安裝步驟

使用yum安裝

1. 安裝系統工具

   1 sudo yum install -y yum-utils device-mapper-persistent-data lvm2

2. 添加軟件源信息

   1 sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3. 更新yum緩存

   1 sudo yum makecache fast

4. 安裝Docker-ce

   docker包含moby（原docker 基礎）、docker-ce（開源 免費）和docker-ee（閉源 收費）

   1 sudo yum -y install docker-ce

5. 啓動Docker後臺任務

   1 sudo systemctl start docker

6. 驗證是否安裝成功（查看Docker版本號）

   1 docker version

使用腳本安裝

1. 使用root權限登陸

2. 確保yum包更新到最新

   1 sudo yum update

3. 執行Docker安裝腳本

   1 curl -fsSL https://get.docker.com -o get-docker.sh
   2 sudo sh get-docker.sh

4. 啓動Docker進程

   1 sudo systemctl start docker

5. 驗證是否安裝成功

   1 docker version

修改工做目錄

1. 查看當前Docker的工做目錄

   1 docker info |grep "Docker Root Dir"

2. 修改Docker工做目錄

   1. 第一個方法

      1. 新建或者編輯/etc/docker/daemon.json

         1 {
         2     "data-root": "/data/docker"
         3 }

      2. 重啓Docker

         1 systemctl restart docker

   2. 第二個方法

      1. 編輯文件/usr/lib/systemd/system/docker.service（位置可能有所差別，可是通常在system目錄中）

         1 [Service]
         2 Type=notify
         3 # the default is not to use systemd for cgroups because the delegate issues still
         4 # exists and systemd currently does not support the cgroup feature set required
         5 # for containers run by docker
         6 ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --data-root=/data/docker
         7 ExecReload=/bin/kill -s HUP $MAINPID
         8 TimeoutSec=0
         9 RestartSec=2……

      2. 重啓Docker

         1 systemctl daemon-reload
         2 systemctl restart docker

鏡像加速

加快Docker鏡像的拉取速度

1. 修改文件/etc/docker/daemon.json

1 {
2    "registry-mirrors": ["http://hub-mirror.c.163.com"]
3 }

2. 修改文件/etc/sysconfig/docker

   1  vim /etc/sysconfig/docker ​

   在文件中添加
   

   1  ADD_REGISTRY='--add-registry http://hub-mirror.c.163.com'

3. 重啓Docker

   1  systemctl restart docker

Docker的刪除

1 sudo yum remove docker-ce
2 sudo rm -rf /var/lib/docker

Docker的安裝（Windows）

官方說明文檔

Windows10專業版

下載和安裝Docker Desktop for Windows

https://hub.docker.com/?overlay=onboarding

其餘版本

下載和安裝docker-toolbox

https://github.com/docker/toolbox/releases

1. 安裝docker-toolbox

2. 驗證是否安裝成功

   進入CMD，執行docker-machine，出現版本信息證實安裝成功

3. 修改docker鏡像保存路徑（默認在C盤的用戶目錄下）

   1. 打開Git Bash

   2. 輸入notepad .bash_profile，建立文件

   3. 在文件中指定鏡像保存路徑

      1 export MACHINE_STORAGE_PATH='鏡像保存路徑（絕對路徑）'

   4. 在指定的路徑中建立cache文件夾

   5. 將安裝目錄下的boot2docker.iso文件複製到cache文件夾中

   6. 進入阿里雲獲取鏡像加速路徑

      https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

   7. 在Git Bash中輸入命令，修改路徑並配置加速

      1 docker-machine -s "指定的鏡像保存路徑" create --engine-registry-mirror=阿里雲加速路徑 -d virtualbox default
      2 //示例
      3 docker-machine -s "H:\dockerProject" create --engine-registry-mirror=https://rf483vio.mirror.aliyuncs.com -d virtualbox default

   8. 運行Oracle VM VirtualBox，或在Git Bash中使用docker-machine查看虛擬機ip地址

   9. 使用SSH工具登陸虛擬機進行操做

   10. 再次開機時，在Git Bash中使用docker-machine start啓動docker-machine

Docker的基本概念

http://dockone.io/article/6051

鏡像（image）

至關於Linux中的root文件系統，提供容器運行時全部的程序、庫、資源、配置參數等

分層設計，每一層構建完成以後就不能再次改變，每次改動只會修改當前層

能夠基於一個鏡像構建新的鏡像

相似於Java中的類

容器（container）

是鏡像運行時的實體，相似於Java中的對象

每一個容器獨立運行，而且擁有本身的存儲空間

一個鏡像能夠建立多個容器來運行

容器中止以後，它佔用的空間都會被清理掉

若是須要將對一個容器的修改保存下來或者須要在多個容器之間共享數據，須要使用數據卷

數據卷

• 概念

  是存在於一個或多個容器中的特定文件或文件夾，這個文件或文件夾以獨立於 docker 文件系統的形式存在於宿主機中。

  數據卷的最大特定是：其生存週期獨立於容器的生存週期

• 使用場景

  在多個容器之間共享數據，多個容器能夠同時以只讀或者讀寫的方式掛載同一個數據卷，從而共享數據卷中的數據。

  當宿主機不能保證必定存在某個目錄或一些固定路徑的文件時，使用數據卷能夠規避這種限制帶來的問題。

  當你想把容器中的數據存儲在宿主機以外的地方時，好比遠程主機上或雲存儲上。

  當你須要把容器數據在不一樣的宿主機之間備份、恢復或遷移時，數據卷是很好的選擇。

• 用法

  1. 使用數據卷

     建立新的數據卷

     1 docker volume create 數據卷名

     顯示數據卷信息

     1 docker volume inspect 數據卷名

     列出全部數據卷

     1 docker volume ls

     刪除全部未使用的數據卷

     1 docker volume prune

     刪除指定數據卷

     1 docker volume rm 數據卷名

  2. 掛載數據卷

     1 //type指定掛載方式，這裏用到的是volume，還有bind和tmpfs。
     2  //volume-driver指定掛載數據卷的驅動程序，默認值是 local。
     3  //source指定掛載的源，對於一個命名的數據卷，這裏應該指定這個數據卷的名稱。在使用時能夠寫source，也能夠簡寫爲src。
     4  //destination指定掛載的數據在容器中的路徑。在使用時能夠寫destination，也能夠簡寫爲dst或target。
     5  //readonly指定掛載的數據爲只讀。
     6  //volume-opt能夠指定屢次，用來提升更多的mount相關的配置。
     7  docker run -id --mount type=volume,source=hello,target=/world ubuntu /bin/bash

  3. 將數據卷存儲到其餘的地方

     1. 安裝vieux/sshfs插件

        1 docker plugin install --grant-all-permissions vieux/sshfs

     2. 建立數據卷，指定遠程登陸主機的用戶名、密碼、數據存放目錄

        1 docker volume create --driver vieux/sshfs -o sshcmd=nick@10.32.2.134:/home/nick/sshvolume -o password=yourpassword mysshvolume

     3. 在啓動容器時掛載數據卷

        1 docker run -id --name testcon --mount type=volume,volume-driver=vieux/sshfs,source=mysshvolume,target=/world ubuntu /bin/bash

倉庫（repository）

集中存放鏡像文件的地方，相似於代碼倉庫

一個倉庫裏面能夠存放不少應用，每一個應用能夠有不少個標籤（版本），經過應用名:版本號惟一標識一個軟件

包含公開的倉庫（Docker Hub）和私有倉庫（Docker Registry鏡像）

Docker的目錄結構

docker默認的工做目錄爲/var/lib/docker

其目錄結構以下

文件夾名稱	描述
bulider
buildkit
containers	存儲容器信息
image	存儲鏡像信息和中間件的信息
image/overlay2
image/overlay2/distribution
image/overlay2/imagedb
image/overlay2/imagedb/content
image/overlay2/imagedb/metadata
image/overlay2/layerdb
image/overlay2/repositories.json
network
overlay2	存儲鏡像管理數據（以存儲驅動命名）
plugins
runtimes
swarm
tmp	docker臨時目錄
trust	docker信任目錄
volumes	docker卷目錄

 

Docker圖形化操做界面

http://www.javashuo.com/article/p-zbzoluhf-hr.html

dockerui

1. 獲取dockerui鏡像

   1  ## 查找鏡像
   2  docker search dockerui
   3  ## 下載鏡像
   4  docker pull abh1nav/dockerui

2. 啓動dockerui容器

   1 docker run -d --privileged --name dockerui -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock abh1nav/dockerui

3. 訪問9000端口

shipyard

1. 獲取shipyard鏡像

   1 ## 官方倉庫下載
   2  docker search dockerui
   3  docker pull shipyard/shipyard
   4 ## 連接獲取
   5  curl -s https://shipyard-project.com/deploy | bash -s

2. 運行shipyard

3. 訪問8080端口

portainer（推薦使用）

1. 獲取portainer鏡像

   1 //搜索
   2  docker search portainer
   3  //獲取
   4  docker pull portainer/portainer 

2. 啓動portainer容器

   1 docker run -d --name portainerUI -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer

3. 訪問9000端口

Docker倉庫

官方倉庫（Docker Hub）

https://hub.docker.com/

以指定格式查詢官方倉庫中的鏡像信息

1 docker search --format "table {{.Name}}\t{{.Description}}\t{{.StarCount}}" 鏡像名稱

查詢官方倉庫鏡像的版本號

• 經過官方網址獲取

  https://hub.docker.com/

• 編寫腳本獲取

  1. 建立腳本文件

     1 touch get_img_tags.sh

  2. 編寫腳本

     1 #!/bin/sh
     2  ​
     3  repo_url=https://registry.hub.docker.com/v1/repositories
     4  image_name=$1
     5  ​
     6  curl -s ${repo_url}/${image_name}/tags | json_reformat | grep name | awk '{print $2}' | sed -e 's/"//g'

  3. 修改腳本文件權限（當前在腳本文件夾所在的目錄）

     1 chmod 777 get_img_tags.sh

  4. 執行腳本（當前在腳本文件夾所在的目錄）

     1 ./get_img_tags.sh 鏡像名稱

使用阿里雲搭建倉庫

1. 登陸阿里雲，按提示建立倉庫

   https://cr.console.aliyun.com/repository/cn-hangzhou/hutianyao/aliyun_docker_warehouse/details

2. 在docker中登陸阿里雲倉庫

   1 docker login --username=阿里雲用戶名 registry.cn-hangzhou.aliyuncs.com

3. 操做阿里雲倉庫

   每一個倉庫的命令可能不同，阿里雲中有操做指南，進入鏡像倉庫頁面點擊對應的倉庫名稱便可看到

   • 拉取鏡像

     1  docker pull registry.cn-hangzhou.aliyuncs.com/阿里雲倉庫命名空間/倉庫名稱:[鏡像版本號]

   • 推送鏡像

     1  ## 登陸
     2  docker login --username=阿里雲用戶名 registry.cn-hangzhou.aliyuncs.com
     3  ## 標記版本
     4  docker tag 鏡像編號 registry.cn-hangzhou.aliyuncs.com/阿里雲倉庫命名空間/倉庫名稱:[鏡像版本號]
     5  ## 推送鏡像
     6  docker push registry.cn-hangzhou.aliyuncs.com/阿里雲倉庫命名空間/倉庫名稱:[鏡像版本號]

搭建私有倉庫

1. 拉取docker-registry鏡像

   1  ## 搜索registry鏡像
   2  docker search registry
   3  ## 拉取registry鏡像
   4  docker pull registry

2. 運行一個registry容器

   1  ## 默認狀況下，倉庫會建立在容器中的/tmp/registry目錄下，經過 -v 指定將鏡像文件存放在本地的目錄中。
   2  docker run -d -p 5000:5000 -v /root/docker/registry:/tmp/registry registry
   3  ​## 示例
   5  docker run -d -p 5000:5000 -v /root/docker/registry:/tmp/registry registry

3. 上傳、下載、搜索倉庫中的鏡像

   • 上傳鏡像

   1  ## 標記鏡像文件
   2  docker tag 鏡像編號 registry容器所在主機的IP地址:registry容器的端口號（默認5000）/上傳鏡像的名稱
   3  ## 示例
   4  docker tag 90a93df7436d 192.168.1.160:5000/centos

   1  ## 上傳鏡像
   2  docker push registry容器所在主機的IP地址:registry容器的端口號（默認5000）/上傳鏡像的名稱
   3  ## 示例
   4  docker push 192.168.1.160:5000/centos

   第一次執行"docker push 192.168.1.160:5000/centos"可能報以下異常：

   1 The push refers to a repository [192.168.1.160:5000/centos]
   2  Get https://192.168.1.160:5000/v1/_ping: http: server gave HTTP response to HTTPS client

   解決方案：

   1. 在/etc/docker目錄下新建 daemon.json, 文件中寫入：

   1  {
   2      "insecure-registries":["192.168.1.160:5000"]
   3  }

   2. 而後重啓docker

      1 systemctl restart docker

   3. 從新運行registry

      1 docker run -d -p 5000:5000 -v /root/docker/registry:/tmp/registry registry

   4. 再次上傳鏡像到私有倉庫

      1 docker push 192.168.1.160:5000/centos

   • 查看私有倉庫的全部鏡像

     1  curl http://倉庫所在主機IP:倉庫registry容器端口號（默認5000）/v2/_catalog
     2  ## 示例
     3  curl http://192.168.1.160:5000/v2/_catalog

   • 下載鏡像

     1  docker pull 倉庫主機編號:倉庫registry容器端口號（默認5000）/倉庫中鏡像的名稱
     2  ## 示例
     3  docker pull 192.168.1.160:5000/mysql

Docker鏡像基本操做

http://www.javashuo.com/article/p-dmmsomqt-ca.html

查看本地所有鏡像

1 docker images

查看本地指定鏡像

1 docker images ls 鏡像名稱:鏡像標籤

查看鏡像詳細信息

1  ## 查看鏡像信息
2   docker inspect 鏡像名稱
3  ## 查看鏡像歷史信息（分層信息）
4   docker history 鏡像名稱

獲取鏡像

從倉庫獲取鏡像

1. 查找倉庫中的鏡像

   1  ## 官方倉庫
   2  docker search 名稱

   1  ## 其餘倉庫
   2  ## 所有
   3  crul 倉庫地址/v2/_catalog
   4  ## 搜索
   5  curl 網址/v2/鏡像名稱/tags/list
   6  ## 示例
   7  curl http://192.168.1.8:5000/v2/image_name/tags/list

2. 拉取須要的鏡像

   1  ## 私有倉庫須要在鏡像名稱以前添加主機ip和端口號
   2  docker pull 鏡像名稱

從本地導入鏡像（.tar.gz文件）

1  cat 本地鏡像文件名稱（包含後綴名） | docker import - 導入鏡像名稱:導入鏡像標籤
2  //示例
3  cat alibaba-rocketmq-3.2.6.tar.gz | docker import - rocketmq:3.2.6

從容器建立一個鏡像

1 docker commit -a 鏡像做者 -m 說明文本 -p（提交時暫停容器） 容器編號 鏡像名稱:鏡像標籤
2  //示例
3  docker commit -a "runoob.com" -m "my apache" a404c6c174a2  mymysql:v1 

使用Dockerfile建立鏡像

http://www.javashuo.com/article/p-hkqaozhz-ht.html

1. 建立鏡像目錄

   1  mkdir myImg
   2  cd myImg

2. 建立DockerFile文件

   1  touch Dockerfile

3. 編寫DockerFile文件

    1 vi Dockerfile
    2  FROM scratch
    3  ​
    4  MAINTAINER hutianyao
    5  ​
    6  ## 建立目錄
    7  RUN mkdir /tags
    8  ​
    9  ## 將安裝包複製到/tags目錄
   10  COPY tool/jdk-8u221-linux-x64.tar.gz /tags
   11  COPY tool/mysql-5.7.27-linux-glibc2.12-x86_64.tar.gz /tags
   12  COPY tool/apache-tomcat-8.5.43.tar.gz /tags
   13  ​
   14  ## 解壓安裝包到相應的目錄
   15  RUN mkdir /apps && cd /apps && mkdir jdk && cd jdk && tar -zxvf /tags/jdk-8u221-linux-x64.tar.gz
   16  ​
   17  RUN cd /apps && mkdir mysql && cd mysql && tar -zxvf /tags/mysql-5.7.27-linux-glibc2.12-x86_64.tar.gz
   18  ​
   19  RUN cd /apps && mkdir tomcat && cd tomcat && tar -zxvf /tags/apache-tomcat-8.5.43.tar.gz
   20  ​
   21  ## 配置環境變量
   22  ENV JAVA_HOME /apps/jdk/jdk-8u221-linux-x64
   23  ENV CATALINA_HOME /usr/local/soft/tomcat
   24  ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin
   25  ​
   26  RUN rm -rf /tags
   27  ​
   28  ##暴露8080端口
   29  EXPOSE 8080
   30  ​
   31  ##啓動時運行Tomact
   32  CMD ["/apps/tomcat/apache-tomcat-8.5.43/bin/catalina.sh","run"]

4. 建立鏡像

   1 docker build -t 鏡像名稱:鏡像標籤 Dockerfile文件路徑
   2  //示例
   3  docker build -t myimage:1.0 .

保存鏡像

1 docker save -o 保存在本地的鏡像名稱.tar 鏡像編號/鏡像名稱
2  //示例
3  docker save -o hello-world.tar 119

載入鏡像

1 docker load --input 本地鏡像名
2 docker load < 本地鏡像名
3  ## 示例
4 docker load < image.tar

刪除鏡像

刪除單個鏡像

1 //其中-f表示當該鏡像存在容器時強制刪除
2  docker image rmi  -f 鏡像編號或鏡像名稱
3  //示例
4  docker rmi 119

刪除指定條件的多個鏡像

1 docker image rmi $(docker image ls 鏡像名稱)

上傳鏡像

1 docker push 鏡像名稱

Docker容器基本操做（鏡像的實例對象）

查看所有容器

1 docker ps -a

查看所有運行中容器

1 docker ps

建立全新的容器

1  docker run 鏡像名稱:鏡像標籤

建立後臺運行容器

當使用docker run命令開啓的容器自動退出或者但願容器在後臺運行時使用

1 docker run -dit 鏡像名稱:鏡像標籤

docker規定，只有當容器中存在前臺運行的進程時，它纔會運行，當不存在前臺進程時，容器會自動退出，所以可使用-dit參數讓容器保持運行

啓動已有的容器

1 docker start 容器編號

終止運行中容器

1 docker stop 容器編號

重啓容器

1 docker restart 容器編號

刪除已終止容器

1  docker rm 容器編號

進入運行中容器內部

1 //默認狀況下軟件安裝的目錄的/ect目錄下
2  docker exec -it 容器編號 /bin/bash
3  docker exec -it 容器編號 /bin/sh

退出容器內部

1 Ctrl+d或exit

容器與宿主機之間的數據傳輸

複製宿主機文件到容器

1 docker cp 宿主機中的文件 容器編號:容器中的文件目錄

複製容器文件到宿主機

1 docker cp 容器編號:容器中的文件目錄 宿主機中的文件目錄

Docker經常使用命令

docker --help

docker命令提示

docker xx --help

docker子命令提示

如：

1 docker run --help

docker images

查看本地docker鏡像

docker search 鏡像名

在docker官方倉庫中查找包含指定名稱的鏡像

docker pull 鏡像名

從docker官方倉庫中下載指定鏡像

docker ps

查看本地運行的全部docker容器

docker run 鏡像名

運行一個鏡像對應的容器

docker exec 容器編號 /bin/bash（docker exec 容器編號 /bin/sh）

進入正在運行的容器內部

Docker基礎鏡像

scratch鏡像

最基礎的鏡像，只能用於構建其餘鏡像，大小几乎爲0，可是沒有Linux工具，經常使用於構建無需編譯的應用鏡像

busybox鏡像

包含一些經常使用的 Linux 工具的鏡像，只有1.16M

Alpine鏡像

是一個高度精簡又包含了基本工具的輕量級 Linux 發行版，基礎鏡像只有 4.41M

CentOS鏡像

200M

Ubuntu鏡像

82.4M

Dockerfile

什麼是Dockerfile

Dockerfile是一個純文本文件，能夠經過Dockerfile快速建立自定義鏡像。

Dockerfile的基本結構

Dockerfile的結構以下：

1. 基礎鏡像

2. 維護者信息

3. 鏡像操做指令

4. 容器啓動指令

示例：

 1 # Dockerfile文件說明
 2  ​
 3  # 建立鏡像時的基礎鏡像（基於那個鏡像來建立鏡像）
 4  FROM ubuntu
 5  ​
 6  # 鏡像維護者說明
 7  MAINTAINER docker_user docker_user@email.com
 8  ​
 9  # 鏡像操做指令
10  RUN echo "deb http://archive.ubuntu.com/ubuntu/ raring main universe" >> /etc/apt/sources.list
11  RUN apt-get update && apt-get install -y nginx
12  RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf
13  ​
14  # 運行容器時的操做指令
15  CMD /usr/sbin/nginx

Dockerfile指令說明

1. FROM

   基礎鏡像信息，即基於哪一個鏡像建立鏡像

   1 FROM centos

2. MAINTAINER

   鏡像維護者信息

   1  MAINTAINER docker_user

3. LABEL

   鏡像元數據，指定的內容能夠在docker inspect時看到

   1 LABEL version="1.0" description="鏡像描述" by="鏡像做者"

4. WORKDIR

   配置建立鏡像時鏡像內部的工做目錄，後面的命令都在此目錄下執行，當目錄不存在時會主動建立

   1 WORKDIR tars

5. USER

   配置建立容器時使用的用戶

   1 USER root:admin

6. COPY

   複製本地主機的文件到容器中的指定路徑

   只支持複製本地主機上的數據

   1  COPY /tool/jdk-8u221-linux-x64.tar.gz /tars

7. ADD

   複製本機指定的文件到容器中的指定路徑

   支持從遠程URL處獲取數據（但不支持認證，如需認證，須要使用RUN wget或RUN curl），而且支持自動解壓文件

   複製本地文件時推薦使用COPY，複製遠程文件時推薦使用RUN wget

   1 ADD https://download.oracle.com/otn-pub/java/jdk/12.0.2+10/e482c34c86bd4bf8b56c0b35558996b9/jdk-12.0.2_linux-x64_bin.tar.gz /apps/jdk/

8. ENV

   指定一個環境變量，會被後續 RUN 指令使用，並在容器運行時保持

   1 ENV JAVA_HOME /apps/jdk/jdk-8u221-linux-x64

9. RUN

   建立鏡像時執行的命令，每條RUN語句執行完成會生成一層鏡像，每層鏡像生成以後不可更改，所以須要儘可能減小RUN的數量

   1 RUN mkdir /apps

10. CMD

    指定啓動容器時執行的命令，每一個 Dockerfile 只能有一條此命令，當指定多個時，只有最後一條會被執行

    其後面的命令能夠在運行容器時使用-e覆蓋

    1 CMD ["/apps/tomcat/apache-tomcat-8.5.43/bin/catalina.sh","run"]

11. ENTRYPOINT

    指定啓動容器時執行的命令，而且不可被 docker run 提供的參數覆蓋，每一個 Dockerfile 中只能有一個ENTRYPOINT，當指定多個時，只有最後一個起效

    其後面的命令不能在運行容器時被覆蓋

    實際使用時可使用ENTRYPOINT指定運行的程序，使用CMD指定運行的參數，這樣能夠更加靈活

    1 ENTRYPOINT ["/apps/tomcat/apache-tomcat-8.5.43/bin/catalina.sh","run"]

12. EXPOSE

    告訴 Docker 服務端容器暴露的端口號，供互聯繫統使用

    1  EXPOSE 8080

13. VOLUME

    建立一個能夠從本地主機或其餘容器掛載的掛載點，通常用來存放數據庫和須要保持的數據等

    1  VOLUME /data
    2  ​
    3  //建立容器時，即將宿主機上的mydata目錄掛載到指定的data目錄
    4  docker run -d -v mydata:/data xxxx

14. ARG

    指定傳遞給構建運行時的變量

    1 ARG site
    2  ARG build_user=IT筆錄
    3  ​
    4  //建立鏡像時能夠傳遞參數
    5  docker build --build-arg site=itiblu.com -t itbilu/test .

15. ONBUILD

    配置當所建立的鏡像做爲其它新建立鏡像的基礎鏡像時，所執行的操做指令。

Q&A

docker爲何能夠實現跨平臺部署？

簡單來講，一個程序運行，須要操做系統的支持，而且須要訪問本身的私有的數據和軟件。 docker是容器，它將全部的訪問文件和操做系統的api從新定向了，讓應用內感受本身在一個獨立的操做系統上運行，而docker攔截了api調用，而且把那些全局的對操做系統的訪問進行了包裝，使得程序不會真的訪問它們。 由於docker程序訪問的是容器包裝的api，理論上說，只要在另外一個操做系統上實現了這些容器的api，就能夠把程序移植上去，由於程序不直接和操做系統打交道，感受不到不一樣系統的不一樣。

docker是否分32和64位？

docker自己只支持安裝在64位的機器上。

docker容器是32位仍是64位的決定於對應的鏡像是多少位的。

docker容器中的用戶與操做系統的用戶有什麼關係？

https://www.cnblogs.com/sparkdev/archive/2018/09/13/9614326.html

http://www.javashuo.com/article/p-kelbhbse-hh.html

當在Dockerfile中沒有指定用戶，而且docker run時也沒有指定用戶時，無論系統用戶的身份是什麼，容器中的身份都是root。

當容器掛載了宿主機目錄時，當前使用容器用戶使用的數據在宿主機中的權限爲當前用戶。

容器內端口的使用規則按照容器內用戶身份來配置，即當docker中用戶爲root是，能夠操做全部端口，當docker中用戶爲普通用戶時，只能操做大於1024的端口。

容器以root身份運行（默認）

1 docker run -it 鏡像名:鏡像tag

容器以指定用戶運行

• 使用Dockerfile配置

  1 USER <user>[:<group>]
  2  #或
  3  USER <UID>[:<GID>]
  4  //示例
  5  USER dockeruserone:dockeruser

• 運行時配置

  1 docker run -u(--user)[user:group] 或 --group-add
  2  //示例
  3  docker run --user=demo_user:group1 --group-add group2 <image_name> <command>

docker建立容器時如何配置CPU、內存、網絡等資源的佔用？

http://www.javashuo.com/article/p-tqtbryin-hw.html

https://cizixs.com/2017/08/04/docker-resources-limit/

直接在建立容器的時候進行配置。

1 docker run -c 設置的CPU權重值 -m 設置的內存使用限額，須要加單位 鏡像名:鏡像tag
2  //示例
3  docker run -c 1024 -m 1g mysql:5.7

docker建立容器時爲何要加上-it？後面的/bin/bash是什麼意思？

-t：讓Docker分配一個僞終端並綁定在容器的標準輸入上

-i：讓容器的標準輸入保持打開

不加-it的話不能與docker容器進行交互；

/bin/bash表示啓動容器使用的腳本引擎，也可在後面在接腳本文件來執行

docker如何在一個容器中運行多個應用，並打包成鏡像？

基於一個已有的容器安裝其餘應用，而後打包成鏡像

或者使用Dockerfile建立一個鏡像。

當一個鏡像中存在多個應用時，如何進行啓動配置？

可在鏡像中建立一個腳本文件，進行啓動配置，而後在啓動鏡像（docker run）時運行這個腳本文件便可（能夠傳入參數）

運行在docker容器中的應用（如MySQL）如何進行配置？

與Linux環境相同，找到安裝目錄進行配置，自定義鏡像能夠指定安裝目錄，方便配置。

怎麼自定義yum安裝應用的路徑？

1 //修改yum安裝文件路徑
2  yum -c /etc/yum.conf --installroot=使用yum安裝軟件的目錄 --releasever=/ install 應用名稱

在使用鏡像建立容器時，怎麼指定運行一個腳本文件？

1  docker run 鏡像名稱:鏡像tag sh引擎 "/etc/rc.d/rc.local;腳本文件"
2  //示例
3  docker run -d --name my_openfalcon -p 8081:8081 my_openfalcon:0.1 /bin/bash -c "/etc/rc.d/rc.local;/apps/start.sh;"

使用鏡像文件建立容器自動中止是什麼緣由？

docker中規定，容器中必需要一個前臺運行的進程，這樣容器才能保持運行。

若是但願容器保持運行，能夠在啓動時加個死循環。

1 docker run -d centos:latest /bin/bash -c "while true; do echo hello world; sleep 1; done"

容器已經在運行，怎麼添加端口映射？

1. 獲取容器ID全值

   1 docker inspect 容器CONTAINER ID

2. 編輯hostconfig.json文件

   1 vim /var/lib/docker/containers/容器編號/hostconfig.json

3. 修改PortBindings項

   在vim模式下可以使用/PortBindings搜索

    1 "PortBindings":{
    2      "容器內端口號/tcp":[
    3          {
    4              "HostIp":"",
    5              "HostPort":"宿主機端口號"
    6          }
    7      ]
    8  }
    9  //示例
   10  "PortBindings":{
   11      "8081/tcp":[
   12          {
   13              "HostIp":"",
   14              "HostPort":"10101"
   15          }
   16      ]
   17  }

4. 保存hostconfig.json文件

   1 :wq

5. 重啓docker服務

   1 systemctl restart docker

容器怎麼備份？

• 直接備份容器

  1  docker export -o 保存文件的名稱.tar 容器編號/名稱

• 建立鏡像備份

  1  ## 建立鏡像
  2  docker commit -a "做者" -m "描述" -p 容器編號 鏡像名稱:鏡像tag
  3  ## 保存鏡像
  4  docker save -o 保存鏡像的名稱.tar 鏡像編號/名稱

• 使用數據卷備份

  http://www.javashuo.com/article/p-febcfbvv-hx.html

  1. 建立容器時掛載數據卷

     1 docker run --name 容器名稱 -v 宿主機目錄:容器目錄 鏡像名稱:鏡像tag

  2. 備份數據卷

     1 docker run --volumes-from 須要備份的容器 -v 備份文件保存的目錄:/backup --name worker ubuntu tar cvf /backup/backup.tar /須要備份的容器
     2  ​
     3  ## 示例
     4  docker run --volumes-from dbdata -v $(pwd):/backup --name worker ubuntu tar cvf /backup/backup.tar /dbdata
     5  ## 首先利用ubuntu鏡像建立了一個容器worker。使用--volumes-from dbdata參數來讓worker容器掛載dbdata容器的數據卷(即dbdata數據卷),使用-v  $(pwd):/backup參數來掛載本地的當前目錄到worker容器的/backup目錄。worker容器啓動後，使用了tar cvf  /backup/backup.tar /dbdata命令來將/dbdata下內容備份爲容器內的/backup/backup.tar，即宿主主機當前目錄下的backup.tar。

  3. 恢復數據

     1. 建立容器掛載數據目錄

        1  docker run -v 須要掛載的數據卷 --name 容器名稱 鏡像名稱:鏡像tag /bin/bash

     2. 建立新容器解壓數據目錄

        1 docker run --volumes-from 須要數據的（上一步中定義的）容器名稱 -v 宿主機備份文件所在目錄:/backup --name worker ubuntu bash
        2  ​
        3  cd 須要掛載的數據卷
        4  ​
        5  tar xvf /backup/backup.tar

在docker中部署web應用

搭建JDK、MySQL、Tomcat環境

1. 獲取MySQL的Docker鏡像

   1 docker search --format="{{.Name}}" mysql
   2  ​
   3  docker pull mysql:5.7

2. 下載JDK、Tomcat的.tar.gz安裝包

   下載JDK的安裝包

   下載Tomcat的安裝包

3. 建立MySQL容器

   1 docker run mysql:5.7

4. 將安裝包複製到容器中指定目錄

   1 docker cp 宿主機安裝包位置 容器編號:容器內目錄
   2  //示例
   3  docker cp /docker/tmp/jdk/jdk-8u221-linux-x64.tar.gz cc6be4b211dd:/jdk
   4  docker cp /docker/tmp/tomcat/apache-tomcat-8.5.43.tar.gz cc6be4b211dd:/tomcat

5. 解壓和安裝JDK

   1. 解壓JDK

   1 tar -zxvf jdk-8u221-linux-x64.tar.gz
   2  chown root:root ~/jdk1.8.0_221 -R

   2. 配置環境變量

      1. 安裝工具

         1 apt-get update
         2  apt-get install vim

      2. 配置環境路徑

         1 vim ~/.bashrc
         2  ​
         3  ##這裏要將目錄要換成jdk解壓的目錄
         4  export JAVA_HOME=/jdk/jdk1.8.0_221
         5  export JRE_HOME=${JAVA_HOME}/jre  
         6  export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib  
         7  export PATH=${JAVA_HOME}/bin:$PATH

      3. 使配置當即生效

         1 source ~/.bashrc

6. 驗證JDK是否成功安裝

   1 java -version

7. 解壓Tomcat

   1  tar -zxvf apache-tomcat-8.5.43.tar.gz

8. 建立運行腳本

   1 touch /root/run.sh
   2  vi /root/run.sh
   3  ​
   4  #!/bin/bash
   5  ## 這裏要換成JDK解壓目錄
   6  export JAVA_HOME=/jdk/jdk1.8.0_221
   7  export PATH=$JAVA_HOME/bin:$PATH
   8  ## 這裏要換成Tomcat解壓目錄
   9  sh /tomcat/bin/catalina.sh run

9. 退出容器並將容器打包成鏡像

   1 docker commit 容器編號 鏡像名稱:鏡像tag
   2  //示例
   3  docker commit cc6be4b211dd myruntime:1.0

部署web應用

1. 在宿主機上建立web應用的存放目錄

   1 # cd /root
   2  # mkdir webapps
   3  # cd webapps/
   4  # mkdir ROOT
   5  # cd ROOT/
   6  # vi index.html

2. 導入web應用

3. 啓動鏡像，並將web應用目錄掛載到容器中Tomcat的webapps目錄

   1 docker run -d -p 宿主機端口:容器內端口 -v 宿主機web應用目錄:容器內Tomcat的webapps目錄 --name 容器名 鏡像名:鏡像tag 鏡像內腳本
   2  //示例
   3  docker run -d -p 58080:8080 -v /root/webapps/:/opt/tomcat/webapps/ --name mytomcat_1 mytomcat:1.0 /root/run.sh

openfalcon鏡像的製做和打包

官方文檔：https://book.open-falcon.org/zh_0_2/quick_install/prepare.html

博客：http://www.javashuo.com/article/p-uvowxgcr-bg.html

獲取一個基礎鏡像（Centos）

1 docker pull centos

運行基礎鏡像，並進入容器內部

1 docker run -dit --name my-openfalcon -p 8081:8081 centos:latest /bin/bash

在容器內部建立須要的文件夾，如臨時文件夾、openfalcon安裝文件夾

1 docker exec -it 84b8a4a13ce4 /bin/bash
2  //建立須要的文件夾
3  cd /
4  mkdir tars
5  mkdir apps

獲取redis、mysql安裝包

使用wget下載redis、mysql安裝包到指定的目錄

1 cd /tars
2  wget http://download.redis.io/releases/redis-5.0.4.tar.gz
3  wget https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.27-linux-glibc2.12-x86_64.tar.gz

也能夠將安裝包放在宿主機上，使用docker cp命令（要在宿主機上執行命令，不能在容器內部執行）將安裝包複製到容器中

1 docker cp 宿主機路徑 容器編號:容器內路徑
2  //示例
3  docker cp /docker/tars/redis-5.0.4.tar.gz 84b8a4a13ce4:/tars
4  docker cp /docker/tars/mysql-5.7.27-linux-glibc2.12-x86_64.tar.gz 84b8a4a13ce4:/tars

安裝redis

http://www.javashuo.com/article/p-euyytplp-u.html

1. 解壓：將下載好的安裝包解壓到指定的目錄下

   1 cd /apps
   2  tar -zxvf redis-5.0.4.tar.gz

2. 編譯：進入解壓目錄，編譯安裝包

   1 cd /apps/redis-5.0.4
   2  make

   注：這裏可能須要安裝make

   1 yum -y install gcc automake autoconf libtool make

3. 安裝：安裝redis

   1 cd src
   2  make install

4. 移動文件：移動文件，方便後續的管理

   1 cd ..
   2  mkdir etc
   3  mkdir bin
   4  ​
   5  mv redis.conf etc/
   6  cd src
   7  mv mkreleasehdr.sh  redis-benchmark  redis-check-aof  redis-check-rdb  redis-cli  redis-sentinel  redis-server  redis-trib.rb ../bin

5. 修改配置文件，使得redis能夠後臺啓動

   將redis.conf中的daemonize false改成daemonize true

   可以使用vim redis.conf進入編輯模式，使用/daemonize進行搜索

6. 啓動redis服務

   在redis安裝目錄的bin下執行（上面已經將文件移到了bin目錄，若是沒有移動，則在src目錄下執行）

   1 ./redis-server redis.conf文件路徑

7. 驗證redis服務是否啓動

   1 pstree -p | grep redis
   2  lsof -i tcp:6379

安裝MySQL

https://blog.csdn.net/yhl_jxy/article/details/53534194

1. 添加MySQL用戶和用戶組

   1 //添加用戶組
   2  groupadd mysql
   3  //添加用戶
   4  useradd -g mysql mysql
   5  //設置mysql用戶的密碼
   6  passwd mysql

2. 解壓tar.gz包

   解壓tar包

   1 cd /apps
   2  tar zxvf mysql-5.7.27-linux-glibc2.12-x86_64.tar.gz

   修改文件夾名稱

   1  cd /apps
   2  mv mysql-5.7.27-linux-glibc2.12-x86_64 mysql-5.7.27

   建立data目錄

   1 cd /apps/mysql-5.7.27
   2  ## 建立目錄
   3  mkdir data
   4  ## 配置權限
   5  chown -R mysql:mysql /apps/mysql-5.7.27/data

3. 安裝MySQL

   注：./mysqld: error while loading shared libraries: libaio.so.1: cannot open shared object file: No such file or directory報錯時可執行：

   yum -y install libaio*

   yum -y install numactl

   1 //前往MySQL bin文件夾
   2  cd /apps/mysql-5.7.27/bin
   3  ​
   4  //安裝MySQL
   5  ./mysqld --initialize --user=mysql --basedir=/apps/mysql-5.7.27/  --datadir=/apps/mysql-5.7.27/data/
   6  ​
   7  //安裝成功，root@localhost: *e8vV=A*sgB_中root爲用戶名*e8vV=A*sgB_爲密碼
   8  2019-08-19T02:46:16.855545Z 1 [Note] A temporary password is generated for root@localhost: *e8vV=A*sgB_

4. 測試啓動

   編輯mysql.server文件

   1 cd /apps/mysql-5.7.27/support-files
   2  ​
   3  vim mysql.server

   修改mysql.server文件中的路徑

   1 basedir=/apps/mysql-5.7.27
   2  ​
   3  datadir=/apps/mysql-5.7.27/data

   啓動測試

   1 cd /apps/mysql-5.7.27/support-files
   2  ./mysql.server start

5. 建立軟鏈接

   給Linux加上MySQL目錄

   1 ln -s /apps/mysql-5.7.27/bin/mysql /usr/bin

6. 建立配置文件

   1 mv /apps/mysql-5.7.27/support-files/my-default.cnf  /etc/my.cnf
   2  ​
   3  [mysqld]
   4  basedir=/apps/mysql-5.7.27
   5  datadir=/apps/mysql-5.7.27/data
   6  character_set_server=utf8
   7  [client]
   8  default-character-set=utf8

7. 重置MySQL密碼

   使用安裝時的密碼登陸MySQL

   1 mysql -u root -p

   運行命令重置密碼

   1 alter user 'root'@'localhost' identified by '123456';

   刷新權限

   1 flush privileges;

初始化MySQL表結構

 1 cd /tmp/ && git clone https://github.com/open-falcon/falcon-plus.git
 2  ​
 3  cd /tmp/falcon-plus/scripts/mysql/db_schema/
 4  ​
 5  mysql -h 127.0.0.1 -u root -p < 1_uic-db-schema.sql
 6  //這裏會提示輸入MySQL的密碼
 7  mysql -h 127.0.0.1 -u root -p < 2_portal-db-schema.sql
 8  //這裏會提示輸入MySQL的密碼
 9  mysql -h 127.0.0.1 -u root -p < 3_dashboard-db-schema.sql
10  //這裏會提示輸入MySQL的密碼
11  mysql -h 127.0.0.1 -u root -p < 4_graph-db-schema.sql
12  //這裏會提示輸入MySQL的密碼
13  mysql -h 127.0.0.1 -u root -p < 5_alarms-db-schema.sql
14  //這裏會提示輸入MySQL的密碼
15  ​
16  rm -rf /tmp/falcon-plus/

檢查表結構是否導入完成

1 mysql -uroot -p
2  ​
3  show databases;
4  ​
5  exit

配置Go語言開發環境

• 使用yum安裝

  1 yum install golang -y

• 使用tar包安裝

  1. 下載tar包（https://golang.org/dl/）

     1 cd /tars
     2  wget https://dl.google.com/go/go1.12.9.linux-amd64.tar.gz

  2. 解壓tar包

     1 tar -C /apps/go-1.12.9 -xzf go1.12.9.linux-amd64.tar.gz

  3. 配置變量

     1  export PATH=$PATH:/apps/go-1.12.9/go/bin

檢查go版本

1 go version

配置環境變量

1 //查看go安裝路徑
2  find / -name go
3  //設置環境變量GOROOT和GOPATH
4  export GOROOT=/apps/go-1.12.9/go
5  export GOPATH=/home

安裝後端

1. 指定安裝目錄

1 export FALCON_HOME=/apps
2  export WORKSPACE=$FALCON_HOME/open-falcon-beckend
3  mkdir $WORKSPACE

2. 下載編譯好的open-falcon二進制版本

1 cd /tars
2  wget https://github.com/open-falcon/falcon-plus/releases/download/v0.3/open-falcon-v0.3.tar.gz

3. 解壓tar包

1 cd $WORKSPACE
2  tar -C $WORKSPACE -xzvf /tars/open-falcon-v0.3.tar.gz

4. 修改配置文件

1 cd $WORKSPACE
2  vim aggregator/config/cfg.json
3  vim graph/config/cfg.json
4  vim hbs/config/cfg.json
5  vim nodata/config/cfg.json
6  vim api/config/cfg.json
7  vim alarm/config/cfg.json

1  //修改前
2  root:@tcp(127.0.0.1:3306)/falcon_portal?loc=Local&parseTime=true
3  //修改後
4  root:123456@tcp(127.0.0.1:3306)/

5. 啓動後端

1 cd $WORKSPACE
2  ## 啓動服務
3  ./open-falcon start
4  ## 查看狀態
5  ./open-falcon check

安裝前端

1. 建立工做目錄

1 export HOME=/apps
2  export WORKSPACE=$HOME/open-falcon-frontend
3  mkdir -p $WORKSPACE

2. 克隆前端代碼

1 cd $WORKSPACE
2  git clone https://github.com/open-falcon/dashboard.git

3. 安裝依賴包

1 yum install -y python-virtualenv
2  yum install -y python-devel
3  yum install -y openldap-devel
4  yum install -y mysql-devel
5  yum groupinstall -y "Development tools"

4. 配置env

   1 cd $WORKSPACE/dashboard/
   2 virtualenv ./env
   3 source env/bin/activate

5. 安裝pip

 1 cd $WORKSPACE
 2  ## 下載和安裝ez_setup.py
 3  wget --no-check-certificate https://bootstrap.pypa.io/ez_setup.py
 4  ​
 5  python ez_setup.py --insecure
 6  ​
 7  ## 下載和安裝pip
 8  wget htps://pypi.python.org/packages/11/b6/abcb525026a4be042b486df43905d6893fb04f05aac21c32c638e939e447/pip-9.0.1.tar.gz#md5=35f01da33009719497f01a4ba69d63c9
 9  ​
10  tar xf pip-9.0.1.tar.gz
11  ​
12  cd pip-9.0.1
13  ​
14  python setup.py install
15  ​
16  cd ..

5. 安裝軟件

查看須要安裝的軟件

1 cd $WORKSPACE/dashboard
2  cat pip_requirements.txt

 

注意：要將pip_requirements.txt中的【Flask == 1.0】改成【Flask==0.10.1】

使用pip安裝軟件

1 cd $WORKSPACE/dashboard
2  pip install -r pip_requirements.txt

6. 修改配置文件

 1 cd $WORKSPACE/dashboard/rrd
 2  cp config.py config.py.bak
 3  vim config.py
 4  ​
 5  ## 根據實際狀況，修改PORTAL_DB_*, 默認用戶名爲root，默認密碼爲""
 6  ## 根據實際狀況，修改ALARM_DB_*, 默認用戶名爲root，默認密碼爲""
 7  PORTAL_DB_USER = os.environ.get("PORTAL_DB_USER","root")
 8  PORTAL_DB_PASS = os.environ.get("PORTAL_DB_PASS","123456")
 9  ​
10  ALARM_DB_USER = os.environ.get("ALARM_DB_USER","root")
11  ALARM_DB_PASS = os.environ.get("ALARM_DB_PASS","123456")

7. 啓動前端服務

1 cd $WORKSPACE/dashboard
2  bash control start
3  ## 或者 
4  ./control start
5  ​
6  ## 查看日誌
7  ./control tail

訪問

http://127.0.0.1:8081

編寫sh文件啓動和關閉服務

啓動服務文件 start.sh

 1 #!/bin/bash
 2  echo "--------------------------------------------------"
 3  echo "服務開始啓動......"
 4  ​
 5  # 啓動redis
 6  cd /apps/redis-5.0.4/bin
 7  ./redis-server ../etc/redis.conf
 8  echo "Redis啓動成功！"
 9  ​
10  # 啓動mysql
11  cd /apps/mysql-5.7.27/support-files
12  ./mysql.server start
13  echo "Mysql啓動成功！"
14  ​
15  # 啓動openfalcon後端
16  cd /apps/open-falcon-beckend
17  ./open-falcon start
18  echo "Openfalcon後端啓動成功！"
19  ​
20  # 啓動openfalcon前端
21  cd /apps/open-falcon-frontend/dashboard
22  ./control start
23  # ./env/bin/python wsgi.py
24  echo "Openfalcon前端啓動成功！"
25  ​
26  echo "服務啓動成功！"
27  echo "--------------------------------------------------"
28  while true; do echo OpenfalconRunning; sleep 1; done

中止服務文件 shutdown.sh

 1 #!/bin/bash
 2  echo "--------------------------------------------------"
 3  echo "開始關閉服務......"
 4  # 關閉openfalcon前端
 5  cd /apps/open-falcon-frontend/dashboard
 6  ./control stop
 7  echo "Openfalcon前端關閉成功！"
 8  ​
 9  # 關閉openfalcon後端
10  cd /apps/open-falcon-beckend
11  ./open-falcon stop
12  echo "Openfalcon後端關閉成功！"
13  ​
14  # 關閉mysql
15  cd /apps/mysql-5.7.27/support-files
16  ./mysql.server stop
17  echo "Mysql關閉成功！"
18  ​
19  # 關閉redis
20  cd /apps/redis-5.0.4/bin
21  ./redis-cli shutdown
22  echo "Redis關閉成功！"
23  ​
24  echo "服務關閉成功！"
25  echo "--------------------------------------------------"

外網訪問

關閉防火牆

1 ## 查看狀態
2  systemctl status firewalld
3  ## 關閉
4  systemctl disable firewalld
5  systemctl stop firewalld
6  ## 開啓
7  systemctl start firewalld

宿主機配置docker容器文件目錄權限，docker容器內部配置openfalcon文件夾權限

1 ## 宿主機
2  chmod -R 755 /var/lib/docker
3  ## 容器內部
4  chmod -R 755 /apps/open-falcon-frontend

提交容器建立鏡像

1 ## 根據容器建立鏡像
2  docker commit -a "hutianyao" -m "my-openfalcon" -p 7915703faac6 my_openfalcon:0.1
3  ## 保存鏡像文件到本地
4  docker save -o /docker/dockerImages/my_openfalcon_v0.1.tar my_openfalcon:0.1
5  ## 上傳鏡像到倉庫（阿里雲）
6  https://cr.console.aliyun.com/repository/cn-hangzhou/hutianyao/my_openfalcon/details

根據鏡像建立容器並運行

https://www.jb51.net/article/48625.htm

建立新的容器

openfalcon須要用到四個端口：

監控信息展現：8081

監控數據上報：1988

監控數據上報：6030、8433

 

1 docker run -d --name my_openfalcon -p 10101:8081 -p 10102:1988 -p 10103:6030 -p 10104:8433 my_openfalcon:0.1 /bin/bash -c "/etc/rc.d/rc.local;/apps/start.sh;"

進入容器

1 docker exec -it 容器編號 /bin/bash
2 
3 ## 示例
4 docker exec -it bec7acdd2e32 /bin/bash

新建MySQL pid文件並授予權限

 1 cd /apps/mysql-5.7.27/data
 2 touch 容器編號.pid
 3 chown -R mysql:mysql 容器編號.pid
 4 chmod -R 755 容器編號.pid
 5 
 6 ## 示例
 7 cd /apps/mysql-5.7.27/data
 8 touch bec7acdd2e32.pid
 9 chown -R mysql:mysql bec7acdd2e32.pid
10 chmod -R 755 bec7acdd2e32.pid

修改後端配置文件

/apps/open-falcon-beckend/agent/cfg.json

 1 {
 2     "debug": true,
 3     "hostname": "",
 4     "ip": "",
 5     "plugin": {
 6         "enabled": false,
 7         "dir": "./plugin",
 8         "git": "https://github.com/open-falcon/plugin.git",
 9         "logs": "./logs"
10     },
11     "heartbeat": {
12         "enabled": true,
13         "addr": "127.0.0.1:10103",//這裏改爲openfalcon安裝宿主機的ip和容器內6030端口對應宿主機映射的端口號（docker run時設置的）
14         "interval": 60,
15         "timeout": 1000
16     },
17     "transfer": {
18         "enabled": true,
19         "addrs": [
20             "127.0.0.1:10104"//這裏改爲openfalcon安裝宿主機的ip和容器內8433端口對應宿主機映射的端口號（docker run時設置的）
21         ],
22         "interval": 60,
23         "timeout": 1000
24     },
25     "http": {
26         "enabled": true,
27         "listen": ":10102",//這裏改爲容器內1988端口對應宿主機映射的端口號（docker run時設置的）
28         "backdoor": false
29     },
30     "collector": {
31         "ifacePrefix": ["eth", "em"],
32         "mountPoint": []
33     },
34     "default_tags": {
35     },
36     "ignore": {
37         "cpu.busy": true,
38         "df.bytes.free": true,
39         "df.bytes.total": true,
40         "df.bytes.used": true,
41         "df.bytes.used.percent": true,
42         "df.inodes.total": true,
43         "df.inodes.free": true,
44         "df.inodes.used": true,
45         "df.inodes.used.percent": true,
46         "mem.memtotal": true,
47         "mem.memused": true,
48         "mem.memused.percent": true,
49         "mem.memfree": true,
50         "mem.swaptotal": true,
51         "mem.swapused": true,
52         "mem.swapfree": true
53     }
54 }

開啓服務

1 cd /apps
2 
3 vim start.sh
4 在最後加上
5 while true; do echo openfalconRuning; sleep 1; done
6 
7 ./start.sh

其餘

• Docker基本概念

• Docker徹底指南

• docker容器詳解

• 深刻理解Docker容器和鏡像

• Docker容器的原理和實踐

• Build（構建鏡像）：鏡像就像是集裝箱包括文件以及運行環境等等資源。

• Ship（運輸鏡像）：主機和倉庫間運輸，這裏的倉庫就像是超級碼頭同樣。Run （運行鏡像）：運行的鏡像就是一個容器，容器就是運行程序的地方。