文档章节

Docker学习总结

o
 osc_ogi0qclx
发布于 2019/08/23 14:16
字数 10073
阅读 13
收藏 0

精选30+云产品,助力企业轻松上云!>>>

什么是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 }
  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

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. 拉取需要的镜像

    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创建镜像

https://www.cnblogs.com/jie-fang/p/7927643.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

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. 编辑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 镜像编号/名称
  • 使用数据卷备份

    https://www.cnblogs.com/kcxg/p/10788769.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
    1. 配置环境变量

      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

博客: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. 编译:进入解压目录,编译安装包

    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
  1. 下载编译好的open-falcon二进制版本

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

1 cd $WORKSPACE
2  tar -C $WORKSPACE -xzvf /tars/open-falcon-v0.3.tar.gz
  1. 修改配置文件

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. 启动后端

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
  1. 克隆前端代码

1 cd $WORKSPACE
2  git clone https://github.com/open-falcon/dashboard.git
  1. 安装依赖包

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. 安装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 ..
  1. 安装软件

查看需要安装的软件

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. 修改配置文件

 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. 启动前端服务

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

其他

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。

暂无文章

OSChina 周一乱弹 —— 毛巾又怎么样?!我在乎的是大姐姐温柔的怀抱!

Osc乱弹歌单(2020)请戳(这里) 【今日歌曲】 @薛定谔的兄弟 :分享洛神有语创建的歌单「我喜欢的音乐」: 《雨 因你而下,于你而止》- Seto 手机党少年们想听歌,请使劲儿戳(这里) @Dan...

小小编辑
7分钟前
19
0
MySQL 常用操作

1 创建/打开/删除数据库 create database db;create database db character set utf8mb4;use db;drop database db;alter database db character set utf8mb4; 2 修复表 mysqlcheck --a......

氷泠
11分钟前
0
0
Node.js中的module.exports与export - module.exports vs exports in Node.js

问题: I've found the following contract in a Node.js module: 我在Node.js模块中找到了以下合同: module.exports = exports = nano = function database_module(cfg) {...} I wonder ......

javail
17分钟前
13
0
如何防止单击按钮时对话框关闭 - How to prevent a dialog from closing when a button is clicked

问题: I have a dialog with EditText for input. 我有一个使用EditText输入的对话框。 When I click the "yes" button on dialog, it will validate the input and then close the dialog.......

富含淀粉
47分钟前
7
0
访问者模式Visitor

一 概述 场景:通常来说,用于封装数据所用到的pojo类,其只包含get、set,对应的业务逻辑是在Service上完成的;但如果出现多个pojo类都共用一套逻辑时,则应该考虑将逻辑进行抽象,不同类型...

小明不觉小
今天
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部