docker

docker

什么是docker

Docker是一个开源的应用容器引擎；是一个轻量级容器技术； Docker支持将软件编译成一个镜像；然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像 运行中的这个镜像称为容器，容器启动是非常快速的

docker的核心概念

  1. docker主机(Host)：安装了docker程序的机器（docker可以直接安装在操作系统上）

  2. docker客户端(Client)：连接docker主机进行操作

  3. docker仓库(Registry)：用来保存各种打包好的软件镜像

  4. docker镜像(Images)：软件打包好的镜像；放在docker仓库中

  5. docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用

  6. 原理图image-20231110210529369

使用docker的步骤

  1. 安装dockersWindows窗口

    image-20231110212202034

  2. 在 Docker Hub 查询对应的组件, 从Docker仓库拉取这个软件/组件对应的镜像

  3. 使用Docker运行这个镜像，这个镜像就会生成一个Docker容器container (配置项,如tomcat镜像中要配置端口, 目录和文件的映射)

  4. 对容器的启动停止,查看日志, 加入网桥( 将容器加入网桥，形成一个局域网，这些容器可以互相访问). 就是对软件的启动停止

docker常用命令

Docker容器信息

1.查看docker容器版本

docker version

2.查看docker容器信息

docker info

3.查看docker容器帮助

docker --help

镜像操作(这里是一个mysql的镜像操作)

搜索镜像

docker search mysql
## --filter=stars=600：只显示 starts(使用数)>=600 的镜像

下载镜像

##下载官方最新镜像，相当于：docker pull musql:latest
docker pull mysql
##下载仓库所有Redis镜像
docker pull -a mysql
##下载时可以指定下载的版本号
docker pull mysql:8

下载镜像查看

##列出本地images
docker images
##含中间映像层
docker images -a
##只显示镜像ID
docker images -q
##含中间映像层
docker images -qa 
##显示镜像摘要信息(DIGEST列)
docker images --digests
##显示镜像完整信息
docker images --no-trunc

示例：image-20231110222710432

镜像删除

##单个镜像删除，相当于：docker rmi redis:latest
docker rmi mysql
##强制删除(针对基于镜像有运行的容器进程)
docker rmi -f mysql
##多个镜像删除，不同镜像间以空格间隔
docker rmi -f mysql tomcat nginx
##删除本地全部镜像
docker rmi -f $(docker images -q)

容器操作

容器启动

docker run -i -t --name mytomcat -p 9000:9000 -d tomcat:latest
##新建并启动容器，参数：-i  以交互模式运行容器；-t  为容器重新分配一个伪输入终端；--name  为容器指定一个名称  -d 以后台进程方式运行 -p 暴露给浏览器的端口
##启动一个或多个已经被停止的容器
docker start redis
##重启容器
docker restart redis

容器的进入与退出

  • centos(容器名)
##使用run方式在创建时进入
docker run -it centos /bin/bash
##关闭容器并退出
exit
##在 centos 容器中打开新的交互模式终端，可以启动新进程，参数：-i  即使没有附加也保持STDIN 打##开；-t  分配一个伪终端
docker exec -i -t  centos /bin/bash
##以交互模式在容器中执行命令，结果返回到当前终端屏幕
docker exec -i -t centos ls -l /tmp
##以分离模式在容器中执行命令，程序后台运行，结果不会反馈到当前终端
docker exec -d centos touch cache.txt

端口映射

docker run -d --name mysql -p 8888:8080 mysql:8
##将宿主机8080的端口映射到容器名为mysql的8888端口

容器的停止与删除

##停止一个运行中的容器
docker stop redis
##杀掉一个运行中的容器
docker kill redis
##删除一个已停止的容器
docker rm redis
##删除一个运行中的容器
docker rm -f redis
##删除多个容器
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm

容器进程

##列出mysql容器中运行进程
docker top mysql

容器日志

##查看mysql容器日志，默认参数
docker logs mysql
##查看mysql容器日志，参数：-f  跟踪日志输出；-t   显示时间戳；--tail  仅列出最新N条容器日志；
docker logs -f -t --tail=20 mysql

查看容器

##查看正在运行的容器
docker ps
##查看正在运行的容器的ID
docker ps -q
##查看正在运行+历史运行过的容器
docker ps -a
##显示运行容器总文件大小
docker ps -s

安装与配置环境

mysql安装

--拉取mysql8的镜像
docker pull mysql:8
--查看
docker images
-- 利用镜像创建mysql8的容器   本机端口为 ３３０８，   解决编码问题
docker run  -p 3308:3306 --name yymysql8 -e MYSQL_ROOT_PASSWORD=a -d  mysql:8 --character-set-server=utf8mb4
--查看容器是否启动
docker ps -a
--进入容器     -it 以交互式终端进入容器 
docker exec -it ycmysql8 /bin/bash
--登录mysql
mysql -uroot -pa
--进入 mysql后 修改密码加密规则 
--如果要允许远程用户也可以连接(比如通过windows主机上的navicat联接), 则不要加＠'localhost'
alter user 'root'@'localhost' identified with mysql_native_password by 'a';
--提取修改到内存
flush privileges;
--创建数据库
create database yc108109res  default character set = 'utf8';
show databases;

dockers容器间的相互访问

桥接模式
存在目的

隔离各个容器，使得每个容器的端口号都是隔离的。如果不隔离开来，那么容器将和宿主机，容器和容器间都会发生端口占用的情况。

桥接模式的原理

docker的桥接网络使用虚拟网桥，bridge网络用于同一主机上的docker容器相互通信，连接到同一个网桥的docker容器可以相互通信，当我们启动docke时，会自动创建一个默认bridge网络，除非我们进行另外的配置，新创建的容器都会自动连接到这个网络，我们也可以自定义自己的bridge网络，docker文档建议使用自定义bridge网络连接到同一bridge网络的容器可以相互访问彼此任意一个端口，如果不发布端口，外界将无法访问这些容器，在创建容器时，通过-p或是–publish指令发布端口

原理图image-20231111192921261
命令
--查看所有网络
docker network ls
--创建bridge网络
docker network create -d bridge ynetwork(网络Id)
--查看某个网络详情
docker network inspect ynetwork(网络id)
--删除某个网络
docker network remove ynetwork
--向网络中添加容器添加两个容器后可以实现相互访问
docker network connect ynetwork mysql8_1(容器名)
效果图image-20231111193449518
示例

两个mysql之间实现相互访问

image-20231111203700014

image-20231111203834564

docker安装fastDFS

--搜索镜像
docker search fastdfs
--下载镜像
docker pull delron/fastdfs

--tracker安装
docker run -d  --name tracker --network=yynetwork -v D:\dockercontainers\fastdfs\tracker:/var/fdfs delron/fastdfs tracker

​ 在D盘中新建\dockercontainers\fastdfs\tracker文件目录 为本地镜像

--安装storage
docker run -d  -p 8888:8888  --name storage --network=ycnetwork  -e TRACKER_SERVER=172.18.0.2:22122 - v D:\dockercontainers\fastdfs\storage:/var/fdfs -e GROUP_NAME=group1 delron/fastdfs storage

==注意安装storage要保证磁盘还有10%剩余空间==

上传图片
本地上传：image-20231111210312987

将要上传的图片拖到这里来，打开命令行窗口执行如下命令

--进入storage
docker exec -it storage bash
--进入目录
cd /var/fdfs
--上传图片
--/usr/bin/fdfs_upload_file /etc/fdfs/client.conf 2.png

效果图image-20231111210843538

它返回给我们的再拼接上localhost:8888(暴露的端口)就可以访问了

image-20231111211110968

项目上传
在一个boot项目中导入依赖
<dependency>
          <groupId>com.luhuiguo</groupId>
          <artifactId>fastdfs-spring-boot-starter</artifactId>
          <version>0.2.0</version>
      </dependency>
文件上传实现类
package com.y.biz.impl;

import com.luhuiguo.fastdfs.domain.StorePath;
import com.luhuiguo.fastdfs.service.FastFileStorageClient;
import com.y.biz.FastDFSBiz;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

/**
 * @program: Spring-boot-demo
 * @description: 图片上传实现类
 * @author: ChestnutDuck
 * @create: 2023-11-08 21:03
 **/
@Component
@Slf4j
public class FastDFSBizImpl implements FastDFSBiz {
    @Autowired
    private FastFileStorageClient fastFileStorageClient;//上传客户端 jar包中已经写好，我们直接用就行
    @Override
    public String upload(MultipartFile photo) {
        String path="group1/M00/00/00/rBIAA2VLbGCAe5Y4AA0eu4FxyD4962.png";//上传失败的默认图片
        StorePath storePath= null;
        try {
            storePath = fastFileStorageClient.uploadFile(IOUtils.toByteArray(photo.getInputStream()),
                    FilenameUtils.getExtension(photo.getOriginalFilename()));
            log.info("上传文件成功，路径信息",storePath);
            log.info("上传文件参数名",photo.getName());
            log.info("文件全路径为：",storePath.getFullPath());
            log.info("path:",storePath.getPath());
            path=storePath.getFullPath(); //这个会返回nginx返回的路径
        } catch (IOException e) {
           e.printStackTrace();
           log.error(e.getMessage());
           return path;
        }
        return path;


    }
}

项目发布

原理图

image-20231111204233349

  • 图中的ip是网桥分配的。

  • 我们发布的项目访问数据库和redis 等是通过桥接访问所以这里访问的其实是它默认的端口 列如项目发布后要访问redis 端口就是默认端口6379 如果是客户端访问则是映射出去的接口图中是(6380)

  • 将项目中yml文件中连接配置进行相应修改image-20231111212419050

  • i修改依赖文件 为了兼容性去掉junit4image-20231111212640875

  • 新增docker 镜像打包插件并在项目下新建Dockerfile文件

    <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <plugin>
                    <groupId>com.spotify</groupId>
                    <artifactId>dockerfile-maven-plugin</artifactId>
                    <version>1.4.13</version>
                    <executions>
                        <execution>
                            <id>default</id>
                            <goals>
                                <goal>build</goal>
                                <goal>push</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <repository>${project.name}</repository>
                        <tag>${project.version}</tag>
                        <buildArgs>
                            <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
                        </buildArgs>
                        <dockerfile>Dockerfile</dockerfile>
                    </configuration>
                </plugin>
            </plugins>
        </build>

    • 将如下内容复制到Dockerfile文件中 

      # 基于 openjdk:8-jre 为基础镜像进行构建
      FROM openjdk:8-jre    
      # 进入这个容器的目录指定为/app
      WORKDIR /app
      # 将jar包放入/app目录下，并重新命名为app.jar
      ADD target/spring-boot-demo-1.0-SNAPSHOT.jar app.jar
      # 该项目使用的是8081端口，所有需要向外暴漏8081端口，日后才能通过映射的端口去访问这个暴漏的端口
      EXPOSE 9999
      # ENTRYPOINT 和 CMD 结合使用，ENTRYPOINT固定命令，CMD根据参数的不同 运行不同的jar包(动态参数)
      ENTRYPOINT ["java","-jar"] 
      CMD ["app.jar"]
      # 相当于 java -jar xxx.jar

  • 开启docker管理端上的暴露image-20231112184413309

  • 打包项目镜像image-20231112190149969

  • 如果项目test阶段有未通过的测试打包时可以跳过测试阶段image-20231112190500943

  • 构建效果如下image-20231112191917200

  • 构建成功后我们可以使用idea连接docker 将打包好的docker推到docker镜像中

    1. 在file->settings->plugins搜索docker 安装image-20231112192407829

    2. 连接docker

    3. image-20231112200206610

    4. 创建项目镜像的容器image-20231112200342619

    5. image-20231112200532629

    6. image-20231112200717454

    7. 将项目对应的容器加入到网络中，这样项目镜像可以通过网桥访问redis，mysql等

      docker network connect yynetwork app
      --yynetwork 是你网络的名字
      --app 是你项目的容器名
命令行构建镜像
  • 上面这种上传镜像会很慢，可以用命令行去构建镜像

  1. 首先去掉pom.xml中这段注释，创建的Dockerfile文件不要删除

    <!--            <plugin>-->
    <!--                <groupId>com.spotify</groupId>-->
    <!--                <artifactId>dockerfile-maven-plugin</artifactId>-->
    <!--                <version>1.4.13</version>-->
    <!--                <executions>-->
    <!--                    <execution>-->
    <!--                        <id>default</id>-->
    <!--                        <goals>-->
    <!--                            <goal>build</goal>-->
    <!--                            <goal>push</goal>-->
    <!--                        </goals>-->
    <!--                    </execution>-->
    <!--                </executions>-->
    <!--                <configuration>-->
    <!--                    <repository>${project.name}</repository>-->
    <!--                    <tag>${project.version}</tag>-->
    <!--                    <buildArgs>-->
    <!--                        <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>-->
    <!--                    </buildArgs>-->
    <!--                    <dockerfile>Dockerfile</dockerfile>-->
    <!--                </configuration>-->
    <!--            </plugin>-->

    b. 将项目打成jar包，右击对应jar包，打开jar包所在文件夹image-20231112202227342

    c. 打开文件夹目录后 在此目录打开终端,输入如下命令

    docker build -t app:1.0 .
    1. docker build --构建镜像
    2. -t 指定构建镜像的名字 
    3. :1.0是指定那个文件
    4. .表示在当前目录下
    注意：要确保当前目录有Dockerfile 文件和对应jar包

    image-20231112202916361

    --创建容器
    docker run -it --name resapp -p 9999:9999 -d res:1.0
    --加入网络中
    docker network connect yynetwork resapp