docker的安装及常用容器的生成

神雕大侠mu

已于 2024-05-24 22:31:12 修改

阅读量1.1k

点赞数 1

分类专栏：云原生docker 文章标签： docker centos linux mysql nginx

于 2021-04-13 16:09:05 首次发布

本文链接：https://blog.csdn.net/m0_37635053/article/details/115669679

版权

云原生docker 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、docker的安装及常用容器的生成

1.1、卸载旧版本docker

用root账号执行：

yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

1.2、安装必备工具

查看当前linux的版本号(centos7才能装)

cat /etc/redhat-release

uname -a

设置stable镜像仓库
官方：（巨坑：外网根本连不上）

yum install -y yum-utils
device-mapper-persistent-data \
lvm2

推荐：阿里云

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

安装gcc相关

yum -y install gcc

yum -y install gcc-c++

yum install -y yum-utils

1.3、告诉linux去哪里下载安装docker

设置stable镜像仓库(阿里云)

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

更新yum软件包索引: yum makecache fast

1.4、安装docker

1.安装最新版官网：yum -y install docker-ce docker-ce-cli containerd.io
2.安装指定版本： yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7 containerd.io-1.4.6

查看版本：docker version
启动：systemctl start docker
停止：systemctl stop docker
状态：systemctl status docker
docker在服务器开机自启动：systemctl enable docker
卸载：
yum remove docker-ce docker-ce-li containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

1.5、配置镜像加速

登录阿里云: https://www.aliyun.com/
新版阿里云镜像加速器地址 https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors
登录后点击控制台，选择左边的
产品与服务--->容器与镜像服务--->镜像加速器 --->centos
依次执行：(在root账号下)

1、mkdir -p /etc/docker
2、tee /etc/docker/daemon.json <<-‘EOF’ {
“registry-mirrors”: [“https://xxxxxx.mirror.aliyuncs.com”]
}
EOF
3、systemctl daemon-reload
4、 systemctl restart docker

1.6、docker开机自启动设置

设置容器在docker重启时自动启动(以mysql为例)：
容器在docker启动时跟随启动：docker update mysql --restart=always
取消开机自启动：docker update mysql --restart=no
docker在服务器开机自启动：systemctl enable docker

进入容器内部的系统，修改容器内容
docker exec -it 容器id /bin/bash

二、docker安装常用镜像

2.1 docker安装mysql

docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=420188 \
-d mysql:5.7

参数解释： docker run是启动一个容器
-p 3306:3306 :是宿主机的3306 对应docker容器内部的3306端口
--name mysql: 是给容器起一个名字
-v /mydata/mysql/log:/var/log/mysql: 其中-v的意思是挂在文件夹，把docker内的/var/log/mysql下面的内容挂在到宿主机的/mydata/mysql/log,记得提前创建好文件目录
-e MYSQL_ROOT_PASSWORD=123456 :是设置mysql的参数 root账号的密码是多少
-d mysql:5.7 :其中-d是后台运行，mysql:5.7是mysql的版本号
进入容器内部：docker exec -it mysql /bin/bash
退出：exit

例如：进入/mydata/mysql/conf直接vim my.cnf 编辑(改变mysql的编码格式)：
[client]
default-character-set=utf8

[mysql] default-character-set=utf8

[mysqld] init_connect=‘SET collation_connection = utf8_unicode_ci’
init_connect=‘SET NAMES utf8’ character-set-server=utf8
collation-server=utf8_unicode_ci skip-character-set-client-handshake
skip-name-resolve

这个时候可以进入容器内部docker exec -it mysql /bin/bash cd /etc/mysql/查看my.cnf
cat my.cnf 就可以看到文件内容与宿主机一致

Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied 解决办法：在挂载目录后多加一个--privileged=true参数即可

docker 安装mysql8.0.20
提前创建目录：

/docker/mysql8.0.20/mysql
/docker/mysql8.0.20/logs
/docker/mysql8.0.20/data

执行创建命令

docker run \
-p 3307:3306 \
--name mysql8 \
--privileged=true \
--restart unless-stopped \
-v /docker/mysql8.0.20/mysql:/etc/mysql8 \
-v /docker/mysql8.0.20/logs:/logs \
-v /docker/mysql8.0.20/data:/var/lib/mysql8 \
-v /etc/localtime:/etc/localtime \
-e MYSQL_ROOT_PASSWORD=420188 \
-d mysql:8.0.20

2.2、docker安装redis

拉取：docker pull redis
创建配置文件夹：mkdir -p /mydata/redis/conf
创建配置文件：touch /mydata/redis/conf/redis.conf

创建并启动容器：

docker run -p 6379:6379 --name redis 
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf

配置redis：

在 /mydata/redis/conf目录下创建redis.conf 编辑： save 900 1 save 300 10 save 60 10000
设置redis连接密码，如果配置了连接密码，客户端在连接redis是需要通过AUTH <password>命令提供密码，默认关闭。例如： requirepass 420188
appendonly yes
指定跟新日志文件名默认为appendonly.aof appendfilename “appendonly.aof”
指定更新日志的条件，有三个可选参数

-no：表示等操作系统进行数据缓存同步到磁盘(快)，
always：表示每次更新操作后手动调用fsync()将数据写到磁盘(慢，安全)，
everysec：表示每秒同步一次(折衷，默认值)；
appendfsync everysec
重启即可设置密码完毕

示例：redis.conf

save 900 1
save 300 10
save 60 10000
requirepass 420188
appendonly yes

2.3、docker 安装elasticsearch

2.3.1 拉取镜像拉取es：`docker pull elasticsearch:7.9.3`

2.3.2 创建文件夹

mkdir -p /mydata/elasticsearch/config 
mkdir -p /mydata/elasticsearch/data

给文件夹赋权: chmod -R 777 /mydata/elasticsearch/ 保证权限

2.3.3 在宿主机创建elasticsearch.yml文件夹

 echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml

2.3.4 创建容器

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms128m -Xmx256m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
 -d elasticsearch:7.9.3

解释：ES_JAVA_OPTS 是设置es的内存占用，
-v是目录挂在到宿主机，前面是宿主机后面是docker里面的路径
-e 是修改参数 plugins是插件目录比如我们放入分词器 执行去问
⑤给目录赋予可读可写可执行权限 chmod -R 777 elasticsearch/
⑥启动 docker start 容器号 (记得开房防火墙端口参看nginx那篇的写法)

2.4、docker安装kibana

2.4.1 拉取kibana:`docker pull kibana:7.9.3`

2.4.2 创建容器

docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.200.141:9200 -p 5601:5601 \
-d kibana:7.9.3

2.5、docker安装nginx

2.5.1

随便启动一个nginx实例，只是为了复制出配置，放到docker里作为镜像的统一配置 docker run -p 80:80 --name nginx -d nginx:1.10

在mydata目录也就是与nginx平级的目录执行： docker container cp nginx:/etc/nginx . 注意：这句话的意思是把虚拟机的nginx的配置文件拷贝到宿主机的nginx目录下，注意结尾是空格点
停掉nginx容器 docker stop nginx
移动配置文件(都是在mydata目录下执行) mv nginx conf mkdir nginx mv conf nginx/
移除容器 docker rm nginx

2.5.2 重新创建nginx容器

docker run -p 80:80 --name nginx \
 -v /mydata/nginx/html:/usr/share/nginx/html \
 -v /mydata/nginx/logs:/var/log/nginx \
 -v /mydata/nginx/conf:/etc/nginx \

-d nginx:1.10 解决nginx中文乱码是在server中配置:charset utf-8; 注意：# 注意一下这个路径映射到了/usr/share/nginx/html，我们在nginx配置文件中是写/usr/share/nginx/html，不是写/mydata/nginx/html
我在/mydata/nginx/html下准备了一个index.html文件在conf下的nginx.conf的配置

server {
       listen       80;
        server_name  localhost;
                charset utf-8;
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
         }

        error_page   500 502 503 504  /50x.html;
         location = /50x.html {
             root   html;
         }
     }

 这里root的路径docker中的路径/usr/share/nginx/html，不是宿主机的路径

2.6、docker安装portainer

2.6.1 拉取镜像 docker pull portainer/portainer
2.6.2 创建数据卷： docker volume create portainer_data
2.6.3 创建并运行容器
创建文件夹
mkdir -p /mydata/portainer/data

docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v /mydata/portainer/data:/data portainer/portainer

参数说明：
-d：容器在后台运行；
-p 9000:9000 ：宿主机9000端口映射容器中的9000端口
-v /var/run/docker.sock:/var/run/docker.sock ：把宿主机的Docker守护进程(Docker daemon)默认监听的Unix域套接字挂载到容器中；
-v /mydata/portainer/data:/data 把宿主机/mydata/portainer/data数据卷挂载到容器/data目录
12.4 访问主机+9000端口即可看到图形化界面(服务器记得打开9000端口的防火墙) 单机版本选择“Local"，点击Connect即可连接到本地docker

2.7、docker安装tomcat

① docker pull tomcat

② docker run -d --name=tomcat8080 -p 8080:8080 -v /mydata/tomcat/webapps:/usr/local/tomcat/webapps/ tomcat

2.8、docker安装nacos

①拉取镜像 pull nacos/nacos-server:2.0.3
②创建目录并授权
mkdir -p /home/soft/nacos/logs
mkdir -p /home/soft/nacos/conf
chmod 777 /home/soft/nacos
③在conf目录创建文件application.properties touch application.properties
④ 配置application.properties中的内容

server.servlet.contextPath=/nacos
### Default web server port:
server.port=8848
 
#*************** Config Module Related Configurations ***************#
### If use MySQL as datasource:
spring.datasource.platform=mysql
### Count of DB:
db.num=1
### Connect URL of DB:
db.url.0=jdbc:mysql://192.168.183.129:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=420188
### Connection pool configuration: hikariCP
db.pool.config.connectionTimeout=30000
db.pool.config.validationTimeout=10000
db.pool.config.maximumPoolSize=20
db.pool.config.minimumIdle=2
nacos.naming.empty-service.auto-clean=true
nacos.naming.empty-service.clean.initial-delay-ms=50000
nacos.naming.empty-service.clean.period-time-ms=30000
management.metrics.export.elastic.enabled=false
#management.metrics.export.elastic.host=http://localhost:9200
### Metrics for influx
management.metrics.export.influx.enabled=false
#management.metrics.export.influx.db=springboot
#*************** Access Log Related Configurations ***************#
### If turn on the access log:
server.tomcat.accesslog.enabled=true
### The access log pattern:
server.tomcat.accesslog.pattern=%h %l %u %t "%r" %s %b %D %{User-Agent}i %{Request-Source}i
 
### The directory of access log:
server.tomcat.basedir=
 
### The ignore urls of auth, is deprecated in 1.2.0:
nacos.security.ignore.urls=/,/error,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-ui/public/**,/v1/auth/**,/v1/console/health/**,/actuator/**,/v1/console/server/**
 
### The auth system to use, currently only 'nacos' and 'ldap' is supported:
nacos.core.auth.system.type=nacos
 
### If turn on auth system:
nacos.core.auth.enabled=false
 
### The token expiration in seconds:
nacos.core.auth.default.token.expire.seconds=18000
### The default token:
nacos.core.auth.default.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789
### Turn on/off caching of auth information. By turning on this switch, the update of auth information would have a 15 seconds delay.
nacos.core.auth.caching.enabled=true
### Since 1.4.1, Turn on/off white auth for user-agent: nacos-server, only for upgrade from old version.
nacos.core.auth.enable.userAgentAuthWhite=false
### Since 1.4.1, worked when nacos.core.auth.enabled=true and nacos.core.auth.enable.userAgentAuthWhite=false.
### The two properties is the white list for auth and used by identity the request from other server.
nacos.core.auth.server.identity.key=serverIdentity
nacos.core.auth.server.identity.value=security
#*************** Istio Related Configurations ***************#
### If turn on the MCP server:
nacos.istio.mcp.server.enabled=false

⑤在配置的数据库中创建库和表详情参考下载的nacos软件包中的 nacos-mysql.sql
⑥镜像制作容器

 docker run --name nacos-server  -p 8848:8848 -p 9848:9848 -p 9849:9849  --privileged=true --restart=always 
 -e JVM_XMS=256m 
 -e JVM_XMX=256m 
 -e MODE=standalone 
 -e PREFER_HOST_MODE=hostname 
 -v /home/soft/nacos/logs:/home/nacos/logs 
 -v /home/soft/nacos/conf/application.properties:/home/nacos/conf/application.properties 
 -d nacos/nacos-server:2.0.3

⑦打开服务器端口
查看已打开的端口 firewall-cmd --list-all
开放端口 firewall-cmd --add-port=8848/tcp --permanent
重载防火墙 firewall-cmd --reload
⑧访问http://192.168.183.129:8848/nacos

2.9 docker安装minio

搜索 : docker search minio

结果:
在这里插入图片描述

拉取镜像   docker pull minio/minio

运行容器

docker run -d -p 9002:9000 -p 9090:9090 --name minio \
-v /usr/local/minio/data:/data \
-v /usr/local/minio/config:/root/.minio \ 
-e "MINIO_ACCESS_KEY=minioadmin" \
-e "MINIO_SECRET_KEY=minioadmin" \
minio/minio server /data --console-address ":9090" -address ":9000"

如上图命令，因为宿主机的9000端口被占用，所以使用宿主机的9002，设置了账号密码，切挂载了数据目录和配置文件

三、手动把jar包做成docker镜像、容器

14.1、在/usr/local/docker/ 如果没有docker目录，就新建一个 mkdir docker传入打好的jar包
14.2、在这个目录创建一个Dockerfile：touch Dockerfile
14.3、编辑Dockerfile：

这是一个编辑好的dockerfile文件：

# 基础镜像使用java 
FROM java:8
# 作者 
MAINTAINER cc <513778675@qq.com>
# VOLUME 指定了临时文件目录为/tmp。 # 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp 
VOLUME /tmp
# 将jar包添加到容器中并更名为monitor.jar 
ADD gulimall-monitor-0.0.1-SNAPSHOT.jar monitor.jar
# 运行jar包 
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/monitor.jar"]

14.4、启动jar包 docker build -t yunpan .
这时查看镜像会看到刚生成的jar包对应镜像
14.5、从镜像制作到容器 docker run -d --name=monitor -p 8091:8091 monotor

四、开启docker的远程访问

15.1 、修改docker.service文件 vim /lib/systemd/system/docker.service#修改ExecStart这行将文件内的 ExecStart注释, 新增如上行。
#ExecStart=/usr/bin/dockerd -H fd://–containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
15.2、重新加载配置文件与测试
重新加载配置文件:systemctl daemon-reload
重启服务:systemctl restart docker.service
查看端口是否开启:netstat -nlpt #如果找不到netstat命令，可进行安装。yum install net-tools
直接curl看是否生效注意：必须要开启防火墙或者阿里云的安全组 2375端口这个端口也可以自定义
curl http://121.89.202.183:2375/info

五、IDEA连接docker，制作镜像、容器

只有第15步完成才能连接docker

16.1、IDEA下载docker插件（就在plugins搜索docker安装即可）
16.2、连接与配置docker：在idea点击settings>Build、Execution、Deployment>Docker
就点Docker标题配置TCP socket 配置docker的地址，默认端口是2375，如果不确定端口是多少，那就在linux用：netstat -nlpt看一眼。

改完点击Apply
16.3、点击展开Docker，选择Docker Registry,在右侧的Address中设置自己的阿里云的docker镜像加速器：https://xxx.mirror.aliyuncs.com

在这里插入图片描述

16.4、docker-maven-plugin生成镜像
在springboot的pom.xml中配置如下：

 <build>
        <finalName>monitor</finalName>
        <plugins>
           <!-- docker-maven-plugin 插件就是为了帮助我们在Maven工程 中，通过简单的配 置，自动生成镜像并推送到仓库中-->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!-- 镜像名称  <docker.image.prefix>monitor</docker.image.prefix>配置在properties中-->
                    <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                    <!--指定标签-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 基础镜像jdk 1.8-->
                    <baseImage>java</baseImage>
                    <!-- 制作者提供本人信息 -->
                    <maintainer>cc 123456@qq.com</maintainer>
                    <!--切换到/ROOT目录 -->
                    <workdir>/ROOT</workdir>
                    <cmd>["java", "-version"]</cmd>
                    <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
                    <!-- 指定 Dockerfile 路径 <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory> -->
                    <!--指定远程 docker api地址-->
                    <dockerHost>http://192.168.200.137:2375</dockerHost>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/ROOT</targetPath>
                            <!--用于指定需要复制的根目录，${project.build.directory} 表示target目 录-->
                            <directory>${project.build.directory}</directory>
                            <!--用于指定需要复制的文件。 ${project.build.finalName}.jar指的是打包 后的jar包文件。-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

打开当前要制作镜像的springboot项目对应的idea的Terminal，输入：
mvn clean package docker:build
看到控制台信息，镜像制作成功。打开IDEA的Services,再点开Docker下的Images，就能看到刚刚制作>的镜像

16.5、由镜像制作容器
点击镜像，右键Create Container,在右侧弹出框只需改动两个地方：Container name和Run options

点击Apply后再点击run就可以创建容器了
这样就可以从Docker>Containers中看到刚创建的容器了，也可以启动停止

16.6 自动制作镜像
上面的镜像制作是手动输入命令，现在教一种自动制作镜像，
在pom.xml中加入一段：

<executions>
 <execution>
      <id>build-image</id>
      <phase>package</phase>
      <goals>
          <goal>build</goal>
      </goals>
  </execution>
</executions>