docker search 关键字

eg:docker search redis

 2)、容器操作

软件镜像 ---- 运行镜像 ---- 产生一个容器 (正在运行的软件);

步骤:

1、搜索镜像
[root@bogon ~]# docker search tomcat
2、拉取镜像
[root@bogon ~]# docker pull tomcat
3、根据镜像启动容器
docker run --name mytomcat -d tomcat:latest
4、docker ps  
查看运行中的容器
5、 停止运行中的容器
docker stop  容器的id
6、查看所有的容器
docker ps -a
7、启动容器
docker start 容器id
8、删除一个容器
 docker rm 容器id
9、启动一个做了端口映射的tomcat
[root@bogon~]# docker run -d -p 8888:8080 tomcat
-d：后台运行
-p: 将主机的端口映射到容器的一个端口    主机端口:容器内部的端口

10、为了演示简单关闭了linux的防火墙
service firewalld status ；查看防火墙状态
service firewalld stop：关闭防火墙
11、查看容器的日志
docker logs container-name/container-id

更多命令参看
https://docs.docker.com/engine/reference/commandline/docker/
可以参考每一个镜像的文档

  3)、安装 MySQL 示例

错误的启动

 1 [root@localhost ~]# docker run --name mysql01 -d mysql
 2 42f09819908bb72dd99ae19e792e0a5d03c48638421fa64cce5f8ba0f40f5846
 3 
 4 mysql退出了
 5 [root@localhost ~]# docker ps -a
 6 CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                           PORTS               NAMES
 7 42f09819908b        mysql               "docker-entrypoint.sh"   34 seconds ago      Exited (1) 33 seconds ago                            mysql01
 8 538bde63e500        tomcat              "catalina.sh run"        About an hour ago   Exited (143) About an hour ago                       compassionate_
 9 goldstine
10 c4f1ac60b3fc        tomcat              "catalina.sh run"        About an hour ago   Exited (143) About an hour ago                       lonely_fermi
11 81ec743a5271        tomcat              "catalina.sh run"        About an hour ago   Exited (143) About an hour ago                       sick_ramanujan
12 
13 
14 //错误日志
15 [root@localhost ~]# docker logs 42f09819908b
16 error: database is uninitialized and password option is not specified 
17   You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD；这个三个参数必须指定一个

正确的启动

1 [root@localhost ~]# docker run --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
2 b874c56bec49fb43024b3805ab51e9097da779f2f572c22c695305dedd684c5f
3 [root@localhost ~]# docker ps
4 CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
5 b874c56bec49        mysql               "docker-entrypoint.sh"   4 seconds ago       Up 3 seconds        3306/tcp            mysql01

做了端口映射

1 [root@localhost ~]# docker run -p 3306:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
2 ad10e4bc5c6a0f61cbad43898de71d366117d120e39db651844c0e73863b9434
3 [root@localhost ~]# docker ps
4 CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
5 ad10e4bc5c6a        mysql               "docker-entrypoint.sh"   4 seconds ago       Up 2 seconds        0.0.0.0:3306->3306/tcp   mysql02

几个其他的高级操作

docker run --name mysql03 -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
把主机的/conf/mysql文件夹挂载到 mysqldocker容器的/etc/mysql/conf.d文件夹里面
改mysql的配置文件就只需要把mysql配置文件放在自定义的文件夹下（/conf/mysql）

docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
指定mysql的一些配置参数

Docker + SpringBoot2.0快速构建镜像

博文链接

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。(引用官方概念，本文注重docker+springboot2.0快速构建镜像，对docker更细节的知识不在做赘述)

Docker

本文使用的是CentOs7

docker 安装：

yum install docker systemctl start docker 开启docker

docker ：修改拉取镜像地址，docker使用默认的公用仓库，在国内下载会比较慢

建议使用ustc拉取 编辑宿主机器文件 ： vi /etc/docker/daemon.json 没有该文件，请先创建一个。 { "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"] } 最后：重启dokcer容器 systemctl restart docker

docker ：常用命令

docker images 列出镜像 docker rmi 镜像 删除镜像 docker rm 容器id 移除容器 docker run -d --name 容器名称 -p 端口 镜像 docker start/stop 容器id 开启/停止容器 docker rm ''docker ps -a -q'' 删除所有的容器 docker ps 查看正在运行的容器 docker ps -a 查看历史运行过的容器 docker ps -l 查看最近运行过的容器

安装私有仓库

执行以下命令，会启动一个registry容器，该容器用于提供私有仓库的服务 没有挂载目录请先创建 docker run --name docker-registry -d -p 5000:5000 -v /usr/local/work/registry:/tmp/registry registry

使用curl -X GET http://192.168.15.129:5000/v2/_catalog 查看私有仓库的镜像信息 如果之前没有创建过，则为空 {"repositories":[]}

使docker 支持http推送镜像 在/etc/docker/daemon.json中配置以下属性，如果多个以逗号分隔。 {"insecure-registries":["192.168.15.129:5000","192.168.15.129"]} 在 /etc/containers/registries.conf中配置 [registries.search] registries = [''docker.io'',''registry.centos.org'',''registry.access.redhat.com'',''192.168.15.129:5000'',''192.168.15.129'']

[registries.insecure] registries =["192.168.15.129:5000","192.168.15.129"] 地址是配置自己搭建的docker仓库私服地址和域名 重新启动Docker systemctl restart docker . 从hub.docker.com中下载一个Tomcat镜像。 使用docker images 查看镜像信息，包括 IMAGE ID。

给该镜像添加一个带有私有仓库的ip的tag docker tag tomcat镜像id 192.168.15.129:5000/tomcat

查看docker images 镜像，多出一个打了tag的tomcat镜像

推送镜像 docker push 192.168.15.129:5000/tomcat

删除从hub.docker.com中pull的镜像

启动私有仓库镜像 docker run --name tomcatpri -d -p 8080:8080 192.168.15.129:5000/tomcat

关闭防火墙，访问Tomcat，成功！

使用docker部署SpringBoot

搭建一个简单的SpringBoot 项目与Docker技术进行整合，使用maven来构建docker镜像并推送至本地docker registry，最后对想不部署时只需要根据对应得镜像启动容器即可。

环境搭建

JDK1.8 SpringBoot2.0.6.RELEASE Maven 3.6.0 Docker

创建一个SpringBoot项目

引入依赖配置

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.6.RELEASE</version>
</parent>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <docker.registry>192.168.15.129:5000</docker.registry>
  </properties>

  <dependencies>
  <dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  
  <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- Docker maven plugin -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!-- docker私服的地址 -->
                    <dockerHost>http://192.168.15.129:2375</dockerHost>
                    <!--镜像名称以及版本号-->
                    <imageName>${docker.registry}/${project.artifactId}:${project.version}</imageName>
                    <!--依赖的基础镜像-->
                    <baseImage>java</baseImage>
                    <!--Dockerfile的位置 -->
                 <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
            <!-- Docker maven plugin -->
        </plugins>
    </build>

编写启动类

编写控制类，用于接收http请求

需要在src/main下面新建一个docker目录，并新建一个Dockerfile文件

  FROM java:8
    
    MAINTAINER lvy lvy@163.com
    
    VOLUME /tmp
    
    ADD docker_registry-0.0.1-RELEASE.jar docker_registry.jar
    
    RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
    && echo ''Asia/Shanghai'' >/etc/timezone
    
    EXPOSE 9000
    
    ENTRYPOINT ["java", "-jar", "docker_registry.jar"]

对Dockerfile里面的内容做一个简单的介绍:

1.FROM:指明当前镜像继承的基础镜像,编译当前镜像时候会自动下载基镜像
2.MAINTAINER:当前镜像的作者和邮箱,使用空格隔开
3.VOLUME:挂载目录
4.ADD:从当前工作目录复制文件到镜像目录中并重新命名
5.RUN:在当前镜像上执行Linux命令,,第二个run指令是为了解决容器和宿主机时间不一致的问题
6.EXPOSE:监听的端口号
7.ENTRYPOINT:让容器像一个可执行程序一样运行

项目构建

使用docker build对项目打包构建 mvn clean install -DskipTests docker:build

这时会报出一个错误 问题1：如果在pom文件里面添加了<dockerHost>节点，并配置了地址是我们搭建的私服地址的话，会报出404 NOT PAGE，如果没有配置该节点会报出链接被拒绝的异常(Connection refused)

解决方案：添加一个``<dockerHost>``节点，值为docker所在机器ip:2375，至于为什么要配置2375，后面会介绍。

问题2：这时在进行 ``mvn clean install -DskipTests docker:build``命令会报出同样的错误，链接被拒绝。
导致原因：
在默认情况下Docker守护进程``Unit socket(/var/run/docker.sock)``来进行本地进程通信，而不会监听任何端口，因此只能在本地使用docker客户端或者使用docker api进行操作。如果想在其他主机上操作docker主机，就需要让docker守护进程打开一个http socket，这样才能实现远程通信，我们是在windows上打包构建的，所以需要让centos7的docker服务开启远程访问。
解决方案：
开启docker远程访问，进入docker私服所在的服务器，编辑配置文件
``vim /usr/lib/systemd/system/docker.service``
在``docker.service``的``[Service]``下增加如下内容
```shell
ExecStart=
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock
```
注意，该端口不是docker私服所在的服务端口，是新开的远程访问端口。进行远程通信的。

同样基于2的基础上，我们还要简历两个软连接，不然执行会报出找不到该命令

 ln -s /usr/libexec/docker/docker-proxy-current /usr/bin/docker-proxy
 
 cd /usr/libexec/docker/
 ln -s docker-runc-current docker-runc

启动

重新读取配置文件并启动docker

systemctl daemon-reload
systemctl restart docker

再次构建

mvn clean install -DskipTests docker:build 发现居然成功了。对！就是这么简单。

查看镜像，运行

使用docker images查看镜像，就会发现刚刚的服务已被打包成镜像了。 使用docker run命令就可以启动容器服务啦！ 启动时需要docker名称+版本号为镜像名称。不然可能找不到(本人机器上如此)

访问服务成功

补充一点： maven 内置变量说明

${basedir} 项目根目录 ${project.build.directory} 构建目录，缺省为target ${project.build.outputDirectory} 构建过程输出目录，缺省为target/classes ${project.build.finalName} 产出物名称，缺省为${project.artifactId}-${project.version} 当前版本 ${project.packaging} 打包类型，缺省为jar

docker - dockerfile构建一个简单的springboot应用镜像

      在前面的 《docker - 构建一个简单的docker镜像》中，介绍了两种构建镜像的方法，其中，通过dockerfile文件构建镜像是在实际生产中常用的；除此之外，还通过 docker - Dockerfile常用指令 和  docker - 常用命令 两篇文章介绍了dockerfile的指令和docker的常用命令，接下来，我们将会使用所学的知识构建一个简单的springboot应用。

    该springboot应用对外暴露了一个api，对外暴露8080端口，日志文件写在应用当前目录，部分代码以及配置文件如下：

@Slf4j
@SpringBootApplication
@RestController
public class SpringbootDockerApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDockerApplication.class, args);
    }

    @RequestMapping("/docker")
    public String docker() {
        log.info("access docker home at " + LocalTime.now());
        return "Hello Docker!";
    }
}

application.properties

spring.application.name=springboot-docker
server.port=8080
logging.file=app.log

把jar和dockerfile文件上传到一个springboot-docker目录中

[root@localhost springboot-docker]# ls
Dockerfile  springboot-docker-1.0.jar

Dockerfile：

FROM openjdk:8u181-jdk-alpine
ARG workdir=/app
VOLUME ${workdir}
WORKDIR ${workdir}
ADD springboot-docker-1.0.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]

• FROM openjdk:8u181-jdk-alpine ： 从docker仓库中获取基础镜像
• ARG workdir=/app ： 添加变量，该变量只在当前的dockerfile中有效，如果换成ENV，则在容器中生效。这里需要注意的是，ARG和ENV对哪些指令是起效的，可以参考  docker - Dockerfile常用指令 
• VOLUME ${workdir} ： 把宿主机的目录（该目录可以通过docker inspect dockerName查看）挂载到容器中的/app这个目录，这样可以在宿主机中查看该目录的内容。还有一个很重要的原因，就是数据持久化，如果不挂载，当容器关闭删除后，数据将会跟着被删除。这里因为/app是应用所在的目录，该目录会产生日志等其它内容。
• WORKDIR ${workdir} ：指定工作目录，下面的指令操作将在这个指定目录中执行。还有一点是，当通过交互模式的exec命令进入到该容器时，默认当前路径是/app
• ADD springboot-docker-1.0.jar app.jar ： 添加文件到WORKDIR
• EXPOSE 8080 ： 暴露8080端口，需要通过容器IP和端口访问应用。如果想通过宿主机的IP和端口访问应用，需要在RUN容器的时候绑定。可以参考docker - Dockerfile常用指令 的run命令
• ENTRYPOINT： 运行容器后执行的第一条命令，这里通过java -jar命令运行应用。

接下通过BUILD命令构建镜像

[root@localhost springboot-docker]# docker build -t springboot-docker:1.0 .

Sending build context to Docker daemon  17.85MB
Step 1/7 : FROM openjdk:8u181-jdk-alpine
 ---> 97bc1352afde
Step 2/7 : ARG workdir=/app
 ---> Using cache
 ---> a3818e8696c2
Step 3/7 : VOLUME ${workdir}
 ---> Using cache
 ---> e2faefe34aa6
Step 4/7 : WORKDIR ${workdir}
 ---> Using cache
 ---> 144b537c1b57
Step 5/7 : ADD springboot-docker-1.0.jar app.jar
 ---> Using cache
 ---> daca849e1012
Step 6/7 : EXPOSE 8080
 ---> Using cache
 ---> 123da0847dd3
Step 7/7 : ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]
 ---> Using cache
 ---> de46a3f96d91
Successfully built de46a3f96d91
Successfully tagged springboot-docker:1.0

查看当前本地仓库的镜像，已经构建springboot-docker:1.0镜像

[root@localhost springboot-docker]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
springboot-docker   1.0                 de46a3f96d91        38 minutes ago      121MB
openjdk             8u181-jdk-alpine    97bc1352afde        5 weeks ago         103MB

运行镜像

docker run -p 8080:8080 -d --name springboot-docker springboot-docker:1.0

通过-p参数，把容器中的8080端口映射到宿主机中的8080端口。--name，给容器起一个名字

可以查看springboot应用的启动情况

docker logs -f springboot-docker 

查看容器的运行情况

docker inspect springboot-docker

只看一些关键的信息

"Mounts": [
            {
                "Type": "volume",
                "Name": "90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3",
                "Source": "/var/lib/docker/volumes/90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3/_data",
                "Destination": "/app",
                "Driver": "local",
            }
        ],
"Networks": {
	"bridge": {
		"Gateway": "172.17.0.1",
		"IPAddress": "172.17.0.2",
	}
}

    宿主机中的 /var/lib/docker/volumes/90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3/_data 目录挂载到 容器的 /app目录

    容器的IP地址 172.17.0.2

    运行成功后，在宿主机中通过命令访问服务

curl 172.17.0.2:8080/docker

    也可以通过宿主机的IP或者localhost访问，因为已经绑定

curl 127.0.0.1:8080/docker

Docker 如何动态给 SpringBoot 项目传参

## 关于 SpringBoot 配置数据源

在项目开发中，我们往往需要配置多套不同的配置环境例如：本地开发、测试环境、部署环境。每一个环境的数据源配置可能都不同，因此需要写不同的数据源配置。如果用 Dockerfile 部署在 Docker 容器中，我们不知道这个项目将来会部署在哪一台服务器上，DataSource 中的 url、username、password 参数，我们都不清楚的时候。可能就没有办法通过默认的 application.yml 来进行配置数据源。

## 如何通过 Docker 给 SpringBoot 项目动态传参

我们都知道 SpringBoot 可以通过 Java -jar *.jar --spring.active=dev 来切换不同的数据源配置，但我不知道怎么通过这种格式去修改 application-dev.yml 中的 url、username、password。于是我就把 DataSource 写在了 application.yml 里

server:
  port: 8080
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username:
    password:
    url:

图中的 DataSource 配置参数都是空的，然后我们编写 Dockerfile 文件

FROM ubuntu:2.0

ADD ./bbs.tar.gz /usr/bbs/
WORKDIR /usr/bbs
#设置变量
ENV username=""
ENV password=""
ENV url=""

#公开端口
EXPOSE 8080
#设置启动命令
ENTRYPOINT ["sh","-c","java -jar pybbs.jar --spring.datasource.username=$username --spring.datasource.url=$url --spring.datasource.password=$password"]

在 Dockerfile 中，我们设置了 3 个 ENV 变量用来给 DataSource 赋值 在 Docker 中我们生成镜像用 docker build -t 镜像名 . 最后启动容器

docker run -d -e username="数据源用户名" -e url="数据库地址" -e password="数据库密码" -p 8080:8080 镜像名

注意！ docker run -e 环境变量必须在 - p 之前，多个环境变量就需要多个 - e, 否则参数传不进去就会报错，这里是一个坑。通过这个步骤我们就可以在 docker run 的时候动态传数据源参数进去就不需要写在 application.yml 里

第一次写博客，如果对你们有帮助麻烦评论啦，谢谢大家！

今天关于docker 构建 springboot 多环境传参和docker部署springboot的讲解已经结束，谢谢您的阅读，如果想了解更多关于(五) SpringBoot 与 Docker、Docker + SpringBoot2.0快速构建镜像、docker - dockerfile构建一个简单的springboot应用镜像、Docker 如何动态给 SpringBoot 项目传参的相关知识，请在本站搜索。