Docker学习总结

什么是Docker

一种软件容器

可以快速的搭建、配置、复制软件的运行环境

为什么要用Docker

  • 一次配置，到处运行，解决软件运行环境不一致的问题，能够提供软件完整的运行环境，提高部署效率

  • 迁移方便，可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。

  • 启动时间快，大大的节约了开发、测试、部署的时间。

  • 具有良好的隔离性，避免软件的相互影响

  • 弹性伸缩，快速扩展，善于处理集中爆发的服务器使用压力

  • 持续交付和部署，可以通过定制应用镜像来实现持续集成、持续交付、部署

Docker的简单使用：Mysql的安装和使用（CentOS 7）

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 7）

安装步骤

使用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 }

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

    1  vim /etc/sysconfig/docker ​
    在文件中添加
    1  ADD_REGISTRY='--add-registry http://hub-mirror.c.163.com'

  2. 重启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图形化操作界面

https://www.cnblogs.com/frankdeng/p/9686735.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  }

    1. 然后重启docker

      1 systemctl restart docker

    2. 重新运行registry

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

    3. 再次上传镜像到私有仓库

      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
      

      

      • 

    

    4. 



Docker镜像基本操作


https://www.cnblogs.com/lsgxeva/p/8746644.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. 

  2. 

    拉取需要的镜像
    

    

    1  ## 私有仓库需要在镜像名称之前添加主机ip和端口号
2  docker pull 镜像名称
    

    

    3. 



从本地导入镜像（.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创建镜像


https://www.cnblogs.com/jie-fang/p/7927643.html


    

  1. 

    创建镜像目录
    

    

    1  mkdir myImg
2  cd myImg
    

    

    2. 

  2. 

    创建DockerFile文件
    

    

    1  touch Dockerfile
    

    

    3. 

  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. 

  4. 

    创建镜像
    

    

    1 docker build -t 镜像名称:镜像标签 Dockerfile文件路径
2  //示例
3  docker build -t myimage:1.0 .
    

    

    5. 



保存镜像




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. 

  2. 

    维护者信息
    

    3. 

  3. 

    镜像操作指令
    

    4. 

  4. 

    容器启动指令
    

    5. 



示例：




 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. 

  2. 

    MAINTAINER
    

    镜像维护者信息
    

    

    1  MAINTAINER docker_user
    

    

    3. 

  3. 

    LABEL
    

    镜像元数据，指定的内容可以在docker inspect时看到
    

    

    1 LABEL version="1.0" description="镜像描述" by="镜像作者"
    

    

    4. 

  4. 

    WORKDIR
    

    配置创建镜像时镜像内部的工作目录，后面的命令都在此目录下执行，当目录不存在时会主动创建
    

    

    1 WORKDIR tars
    

    

    5. 

  5. 

    USER
    

    配置创建容器时使用的用户
    

    

    1 USER root:admin
    

    

    6. 

  6. 

    COPY
    

    复制本地主机的文件到容器中的指定路径
    

    只支持复制本地主机上的数据
    

    

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

    

    7. 

  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. 

  8. 

    ENV
    

    指定一个环境变量，会被后续 RUN 指令使用，并在容器运行时保持
    

    

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

    

    9. 

  9. 

    RUN
    

    创建镜像时执行的命令，每条RUN语句执行完成会生成一层镜像，每层镜像生成之后不可更改，因此需要尽量减少RUN的数量
    

    

    1 RUN mkdir /apps
    

    

    10. 

  10. 

    CMD
    

    指定启动容器时执行的命令，每个 Dockerfile 只能有一条此命令，当指定多个时，只有最后一条会被执行
    

    其后面的命令可以在运行容器时使用-e覆盖
    

    

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

    

    11. 

  11. 

    ENTRYPOINT
    

    指定启动容器时执行的命令，并且不可被 docker run 提供的参数覆盖，每个 Dockerfile 中只能有一个ENTRYPOINT，当指定多个时，只有最后一个起效
    

    其后面的命令不能在运行容器时被覆盖
    

    实际使用时可以使用ENTRYPOINT指定运行的程序，使用CMD指定运行的参数，这样可以更加灵活
    

    

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

    

    12. 

  12. 

    EXPOSE
    

    告诉 Docker 服务端容器暴露的端口号，供互联系统使用
    

    

    1  EXPOSE 8080
    

    

    13. 

  13. 

    VOLUME
    

    创建一个可以从本地主机或其他容器挂载的挂载点，一般用来存放数据库和需要保持的数据等
    

    

    1  VOLUME /data
2  ​
3  //创建容器时，即将宿主机上的mydata目录挂载到指定的data目录
4  docker run -d -v mydata:/data xxxx
    

    

    14. 

  14. 

    ARG
    

    指定传递给构建运行时的变量
    

    

    1 ARG site
2  ARG build_user=IT笔录
3  ​
4  //创建镜像时可以传递参数
5  docker build --build-arg site=itiblu.com -t itbilu/test .
    

    

    15. 

  15. 

    ONBUILD
    

    配置当所创建的镜像作为其它新创建镜像的基础镜像时，所执行的操作指令。
    

    16. 



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


https://segmentfault.com/a/1190000016781704


当在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、内存、网络等资源的占用？


https://www.cnblogs.com/zhuochong/p/9728383.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. 

  2. 

    编辑hostconfig.json文件
    

    

    1 vim /var/lib/docker/containers/容器编号/hostconfig.json
    

    

    3. 

  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. 

  4. 

    保存hostconfig.json文件
    

    

    1 :wq
    

    

    5. 

  5. 

    重启docker服务
    

    

    1 systemctl restart docker
    

    

    6. 



容器怎么备份？


    

  • 

    直接备份容器
    

    

    1  docker export -o 保存文件的名称.tar 容器编号/名称
    

    

    • 

  • 

    创建镜像备份
    

    

    1  ## 创建镜像
2  docker commit -a "作者" -m "描述" -p 容器编号 镜像名称:镜像tag
3  ## 保存镜像
4  docker save -o 保存镜像的名称.tar 镜像编号/名称
    

    

    • 

  • 

    使用数据卷备份
    

    https://www.cnblogs.com/kcxg/p/10788769.html
    

      

    1. 

      创建容器时挂载数据卷
      

      

      1 docker run --name 容器名称 -v 宿主机目录:容器目录 镜像名称:镜像tag
      

      

      2. 

    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. 

    3. 

      恢复数据
      

        

      1. 

        创建容器挂载数据目录
        

        

        1  docker run -v 需要挂载的数据卷 --name 容器名称 镜像名称:镜像tag /bin/bash
        

        

        2. 

      2. 

        创建新容器解压数据目录
        

        

        1 docker run --volumes-from 需要数据的（上一步中定义的）容器名称 -v 宿主机备份文件所在目录:/backup --name worker ubuntu bash
2  ​
3  cd 需要挂载的数据卷
4  ​
5  tar xvf /backup/backup.tar
        

        

        3. 

      4. 

    • 



在docker中部署web应用


搭建JDK、MySQL、Tomcat环境


    

  1. 

    获取MySQL的Docker镜像
    

    

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

    

    2. 

  2. 

    下载JDK、Tomcat的.tar.gz安装包
    

    下载JDK的安装包
    

    下载Tomcat的安装包
    

    3. 

  3. 

    创建MySQL容器
    

    

    1 docker run mysql:5.7
    

    

    4. 

  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. 

  5. 

    解压和安装JDK
    

      

    1. 

      解压JDK
      

      2. 

    

    

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

    

      

    1. 

      配置环境变量
      

        

      1. 

        安装工具
        

        

        1 apt-get update
2  apt-get install vim
        

        

        2. 

      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. 

      3. 

        使配置立即生效
        

        

        1 source ~/.bashrc
        

        

        4. 

      2. 

    6. 

  6. 

    验证JDK是否成功安装
    

    

    1 java -version
    

    

    7. 

  7. 

    解压Tomcat
    

    

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

    

    8. 

  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. 

  9. 

    退出容器并将容器打包成镜像
    

    

    1 docker commit 容器编号 镜像名称:镜像tag
2  //示例
3  docker commit cc6be4b211dd myruntime:1.0
    

    

    10. 



部署web应用


    

  1. 

    在宿主机上创建web应用的存放目录
    

    

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

    

    2. 

  2. 

    导入web应用
    

    3. 

  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
    

    

    4. 



openfalcon镜像的制作和打包


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


博客：https://www.cnblogs.com/nulige/p/7741580.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


https://blog.csdn.net/u011669700/article/details/79566713


    

  1. 

    解压：将下载好的安装包解压到指定的目录下
    

    

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

    

    2. 

  2. 

    编译：进入解压目录，编译安装包
    

    

    1 cd /apps/redis-5.0.4
2  make
    

    

    注：这里可能需要安装make
    

    

    1 yum -y install gcc automake autoconf libtool make
    

    

    3. 

  3. 

    安装：安装redis
    

    

    1 cd src
2  make install
    

    

    4. 

  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. 

  5. 

    修改配置文件，使得redis可以后台启动
    

    将redis.conf中的daemonize false改为daemonize true
    

    可使用vim redis.conf进入编辑模式，使用/daemonize进行搜索
    

    6. 

  6. 

    启动redis服务
    

    在redis安装目录的bin下执行（上面已经将文件移到了bin目录，如果没有移动，则在src目录下执行）
    

    

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

    

    7. 

  7. 

    验证redis服务是否启动
    

    

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

    

    8. 



安装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. 

  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. 

  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. 

  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. 

  5. 

    创建软连接
    

    给Linux加上MySQL目录
    

    

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

    

    6. 

  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. 

  7. 

    重置MySQL密码
    

    使用安装时的密码登录MySQL
    

    

    1 mysql -u root -p
    

    

    运行命令重置密码
    

    

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

    

    刷新权限
    

    

    1 flush privileges;
    

    

    8. 



初始化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. 

    2. 

      解压tar包
      

      

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

      

      3. 

    3. 

      配置变量
      

      

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

      

      4. 

    • 



检查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. 

    指定安装目录
    

    2. 





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




    

  1. 

    下载编译好的open-falcon二进制版本
    

    2. 





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




    

  1. 

    解压tar包
    

    2. 





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




    

  1. 

    修改配置文件
    

    2. 





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)/




    

  1. 

    启动后端
    

    2. 





1 cd $WORKSPACE
2  ## 启动服务
3  ./open-falcon start
4  ## 查看状态
5  ./open-falcon check




安装前端


    

  1. 

    创建工作目录
    

    2. 





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




    

  1. 

    克隆前端代码
    

    2. 





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




    

  1. 

    安装依赖包
    

    2. 





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"




    

  1. 配置env

    

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

    

    2. 

  2. 

    安装pip
    

    3. 





 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 ..




    

  1. 

    安装软件
    

    2. 



 查看需要安装的软件




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




    

  1. 

    修改配置文件
    

    2. 





 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")




    

  1. 

    启动前端服务
    

    2. 





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




其他







		

		
posted @ 
2019-08-23 14:16 
小星- 
阅读(849) 
评论(0) 
编辑 
收藏 
举报