Docker常用命令

Docker常用命令

Docker配置阿里云镜像加速

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://7fsjirqs.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

验证Docker的镜像加速是否生效

[root@localhost ~]# docker info
		..........
    127.0.0.0/8
   Registry Mirrors:
    'https://lz2nib3q.mirror.aliyuncs.com/'
   Live Restore Enabled: false
   Product License: Community Engine

启动Docker

systemctl start docker

显示 Docker 版本信息

docker version

显示 Docker 系统信息，包括镜像和容器数

docker info

帮助命令

docker --help

查看镜像信息

docker images	[options]	#列出本地所有镜像
	-a			#列出所有镜像（包含中间映像层）
    -q			#只显示镜像id
    --digests	#显示镜像摘要信息
    --no-trunc	#不截断输出（默认截断过长的列） 完整展示

搜索镜像

docker search [options] 镜像名		#去dockerhub上查询当前镜像
	-s 指定值		#列出收藏数不少于指定值的镜像
    --no-trunc	  #不截断输出（默认截断过长的列） 完整展示

删除镜像

docker rmi 镜像名:版本	  #未指定版本删除最新版本
	-f		#强制删除 

运行容器

docker run [OPTIONS] 镜像名 [cmd]			   #镜像名新建并启动容器
	-i							#以交互模式运行容器，通常与-t同时使用
	-t							#为容器重新分配一个伪终端，通常与-i同时使用
	--name 别名				   #为容器指定一个名字
	-d							#启动守护式容器（在后台启动容器）,并返回容器ID
	-p 映射端口号：原始端口号		 #指定端口号启动,指定端口映射
	-P							#主机自动分配端口号,随机端口映射
	--rm                        #当容器停止自动移除                                  
	
例：$ docker run -it --name myTomcat -p 8888:8080 tomcat
    $ docker run -d --name myTomcat -P tomcat

查看运行的容器

docker ps		 #列出所有正在运行的容器
	-a			#显示所有的容器，包括未运行的。
	-l			#显示最近创建的一个容器
	-n 数值	   #显示最近n个创建的容器
	-q			#静默模式，只显示容器编号
	--no-trunc	 #不截断输出（默认截断过长的列） 完整展示

输出详情介绍：

**CONTAINER ID:** 容器 ID。

**IMAGE:** 使用的镜像。

**COMMAND:** 启动容器时运行的命令。

**CREATED:** 容器的创建时间。

**STATUS:** 容器状态。

状态有7种：

- created（已创建）
- restarting（重启中）
- running（运行中）
- removing（迁移中）
- paused（暂停）
- exited（停止）
- dead（死亡）

退出容器

exit		 #容器停止退出
Ctrl+p+q	 #容器不停止退出 

进入容器

docker attach 容器名字/容器id

docker exec [options] 容器名字/容器id 容器内命令   		
	-i		#以交互模式运行容器，通常与-t一起使用
	-t		#分配一个伪终端

eg: docker exec -it centoss ls 

docker exec -it mytomcat /bin/bash

删除容器

docker rm  容器名字/容器id		  #删除容器
docker rm -f 	容器名字/容器id	  #删除正在运行的容器
docker rm -f $(docker ps -aq)	   #删除所有容器

重启容器

docker start 容器名字/容器id  	    #开启容器
docker restart 容器名字/容器id  	#重启容器

停止正在运行的容器

docker stop 容器名字/容器id 	   	#正常停止容器运行
docker kill 容器名字/容器id     	#立即停止容器运行

查看容器日志

docker logs [OPTIONS] 容器名字/容器id	  		
	-t			 #加入时间
	-f			 #跟随最新的日志打印
	--tail 数字	#显示最后多少条

查看容器内的进程

docker top 容器名字/容器id   

查看容器内部细节

docker inspect 容器名字/容器id    

拷贝

docker cp 容器名字/容器id:容器内资源路径 宿主机目录路径  		#将容器内资源拷贝到主机上

eg:
docker cp centoss:/aaa.txt /root/

#宿主机与容器之间可以相互分享文件
docker cp 宿主机目录路径 容器名字/容器id:容器内资源路径

eg:docker cp /root/bbb.txt centoss:/

宿主机:Docker安装在哪谁就是宿主机  centos
容器:在Docker种根据镜像启动的就是容器   centos容器

把一个容器副本打包镜像

docker commit -a="作者" -m="描述信息" 容器ID 目标镜像名称:TAG

例：docker commit -a="nan" -m="witout docs" b35d35f72b8d nan/mytomcat:1.2
	1.从dockerHub上下载tomcat镜像到本地并成功运行
	2.删除上一步镜像产生的容器的doc目录
	3.以当前没有doc目录的tomcat为模板commit生成一个新的镜像
	4.启动新的镜像并和原来的对比

将指定镜像保存成 tar 归档文件

docker save IMAGEID [OPTIONS] filename
	-o   #输出到的文件。

eg:docker save tomcat:8.5.50 -o tomcat-8.5.50.tar

导入使用 docker save命令导出的镜像

docker load [OPTIONS]
    -i 	#指定导入的文件，代替 STDIN。
eg:docker load -i mysql-5.6.tar 

列出指定的容器的端口映射

docker port [OPTIONS] CONTAINER [PRIVATE_PORT[/PROTO]]

添加数据卷

命令：docker run -it -v /宿主机的路径:/容器内的路径 镜像名

例子：docker run -it -v /hostDataValueme:/containerDataValueme centos

查看数据卷是否挂成功

运行 docker inspect 容器id 命令 检查json串里有没有以下内容，如果有则证明卷挂载成功

"Mounts": [
            {
                "Type": "bind",
                "Source": "/hostDataValueme",
                "Destination": "/containerDataValueme",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ]

设置容器内数据卷只读

命令：docker run -it -v /主机路径:/容器内路径:ro 镜像名
例子：docker run -it -v /hostDataValueme:/containerDataValueme:ro centos

高级数据卷配置

1.创建数据卷
docker volume create my-vol

2.查看数据卷细节
docker volume inspect my-vol       
[
    {
        "CreatedAt": "2020-11-25T11:43:56+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
        "Name": "my-vol",
        "Options": {},
        "Scope": "local"
    }
]

3.挂载数据卷
docker run -d -P --name web  -v my-vol:/usr/share/nginx/html  nginx
docker inspect web
				"Mounts": [
            {
                "Type": "volume",
                "Name": "my-vol",
                "Source": "/var/lib/docker/volumes/my-vol/_data",
                "Destination": "/usr/share/nginx/html",
                "Driver": "local",
                "Mode": "z",
                "RW": true,
                "Propagation": ""
            }
        ],

删除指定数据卷

docker volume rm my-vol

查看所有数据卷

docker volume ls

安装Tomcat

# 1.在docker hub搜索tomcat
	docker search tomcat

# 2.下载tomcat镜像
	docker pull tomcat

# 3.运行tomcat镜像
	docker run -p 8080:8080 -d --name mytomcat tomcat

# 4.进入tomcat容器
	docker exec -it mytomcat /bin/bash

# 5.将webapps目录挂载在外部
	docker run -p 8080:8080 -v /root/webapps:/usr/local/tomcat/webapps -d --name mytomcat tomcat

---

安装mysql

1.在DockerHub上查找mysql镜像

$ docker search mysql

2.将mysql拉去到本地

$ docker pull mysql:5.6

3.运行mysql容器

# 没有暴露外部端口外部不能连接
$ docker run --name mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:tag

# 没有暴露外部端口
$ docker run --name mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 -d  mysql:tag

#为用户设置客户端连接密码
-e MYSQL_ROOT_PASSWORD=root 

**4.进入这个容器 **

$ docker exec -it 容器id /bin/bash

5.Mysql操作

#进入mysql  
mysql -u root -p 
#输入密码 123456

#查询mysql的库    
show databases;

#创建数据库    
create database ems;

#切换到db01     
use ems;

#建表
create table t_book(id int not null primary key, name varchar(20));

#查询所有表
show tables;

#向表中插入一条数据  
insert into t_book values(1,'java');

#查询这张表的数据 
select * from t_book;

#用我们外部win10的大黄navcat尝试连接这个mysql

查看MYSQL日志

$ docker logs 容器名称|容器id

$ docker run -p 映射端口:3306 --name 自定义名字 -v 宿主机目录:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=自定义密码 -d mysql:tag 

#eg: 
docker run -p 3335:3306 --name mysqlw -v mysqlData:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.6 

8.自定义的MySQL配置文件

MySQL的默认配置可以在中找到/etc/mysql/my.cnf，其中可以包含!includedir其他目录，例如/etc/mysql/conf.d或/etc/mysql/mysql.conf.d。请检查mysql映像本身中的相关文件和目录，以获取更多详细信息。

$ docker run --name mysql -v /root/mysql/conf.d:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#eg: 
docker run -p 3335:3306 --name mysqlw -v mysqlConfig:/etc/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.6


#启动Mysql 指定端口并数据备份以及本地保存配置文件
docker run -p 3335:3306 --name mysqlw -v mysqlData:/var/lib/mysql -v mysqlConfig:/etc/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.6

9.将mysql数据库备份为sql文件

# 1.导出全部数据
$ docker exec 容器名|容器id sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > /some/path/on/your/host/all-databases.sql
	
#eg:	
docker exec b8d36482dffc sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/all-databases.sql


# 2.导出指定库数据
$ docker exec mysql sh -c 'exec mysqldump --databases 库表 -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/all-databases.sql  

#eg:
docker exec b8d36482dffc sh -c 'exec mysqldump --databases yingx -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/users.sql

# 3.导出指定库数据不要数据
$ docker exec mysql sh -c 'exec mysqldump --no-data --databases 库表 -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/all-databases.sql 

#eg:
docker exec b8d36482dffc sh -c 'exec mysqldump --no-data --databases yingx -uroot -p"$MYSQL_ROOT_PASSWORD"' > /root/user.sql 

10.从转储文件还原数据

$ docker exec -i mysql sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /root/xxx.sql

#eg:
docker exec -i b859bba6e061 sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /root/all-databases.sql

docker exec -i ef12e2c085dd sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /root/yingx.sql

安装Redis服务

1. 在DockerHub上查找redis镜像

$ docker search redis

2. 将redis拉去到本地

$ docker pull redis:4.0.14

3. 启动redis服务运行容器

#没有暴露外部端口
$ docker run --name redis -d redis:tag

#暴露外部宿主机端口为6379进行连接
$ docker run -d --name redis -p 6379:6379 redis:tag
$ docker run -it --name redis -p 6379:6379 redis:tag
$ docker run -it --name redis -p 6379:6379 redis:tag redis-server

4.查看启动日志

$ docker logs -t -f 容器id|容器名称

5.连接redis客户端

# 1.默认端口连接
$ docker exec -it 容器id redis-cli
# 2.指定端口连接
$ docker exec -it 容器id redis-cli -h 192.168.253.128 -p 6370

#命令说明：
-h 192.168.253.128 : #指定连接地址
-p 6370 : #指定连接端口

5.指定AOF持久化

如果启用了持久性，则数据存储在中VOLUME /data，可以与--volumes-from some-volume-container或一起使用-v /docker/host/dir:/data

$ docker run --name 容器id -d -p 6379:6379 redis:tag redis-server --appendonly yes

$ docker run --name 容器id -d -p 6379:6379 -v /docker/host/dir:/data redis:tag redis-server --appendonly yes

#eg:
$ docker run --name redis -d -p 6379:6379 -v redisData:/data redis:4.0.14 redis-server --appendonly yes

6. 自定义配置启动Redis容器

默认情况下redis官方镜像中没有redis.conf配置文件 需要去官网下载指定版本的配置文件

1. wget http://download.redis.io/releases/redis-5.0.8.tar.gz 下载官方安装包
2. 将官方安装包中配置文件进行复制到宿主机指定目录中如 /root/redis/redis.conf文件

1.创建配置文件

#创建文件夹,新建配置文件贴入从官网下载的配置文件并修改
mkdir /root/redis/
vim /root/redis/redis.conf

2.修改需要自定义的配置

bind 0.0.0.0   #开启远程权限
port 7000      #启动端口
appenonly yes  #开启aof持久化

3.配置文件介绍

bind 127.0.0.1       #bind:绑定redis服务器网卡IP，默认为127.0.0.1,即本地回环地址。这样的话，访问redis服务只能通过本机的客户端连接，而无法通过远程连接。如果bind选项为空的话，那会接受所有来自于可用网络接口的连接。

protected-mode yes    #默认yes，开启保护模式，限制为本地访问,改为 no关闭保护模式

port 6379           #指定redis运行的端口，默认是6379。由于Redis是单线程模型，因此单机开多个Redis进程的时候会修改端口。

timeout 0           #设置客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接。默认值为0，表示不关闭。

daemonize no   #默认no，改为yes意为以守护进程方式启动，可后台运行，除非kill进程，改为yes会使配置文件方式启动redis失败

databases 16   #数据库个数，默认值是 16，也就是说默认Redis有16个数据库。

appendonly no #默认redis使用的是rdb方式持久化，这种方式在许多应用中已经足够用了，改为yes开启aof持久化持久化

4…指定配置文件启动

$ docker run -p 7001:7000 --name redis -v /usr/local/docker/redis.conf:/etc/redis/redis.conf -v /usr/local/docker/data:/data -d redis:4.0.14 redis-server /etc/redis/redis.conf --appendonly yes

#eg:
$ docker run -d -p 7001:7000 --name redis -v /root/redis/redis.conf:/etc/redis/redis.conf redis:4.0.14 redis-server /etc/redis/redis.conf

#命令解释说明：
-p 7001:7000 #端口映射：前表示主机部分，：后表示容器部分。
-v #挂载目录，规则与端口映射相同。
redis-server /etc/redis/redis.conf #以配置文件启动redis，加载容器内的conf文件，最终找到的是挂载的目录/usr/local/docker/redis.conf

7.将数据目录挂在到本地保证数据安全

$ docker run -p 6379:6379 -d --name redis -v /root/redis/data:/data -v /root/redis/redis.conf:/etc/redis/redis.conf redis:4.0.14 redis-server /etc/redis/redis.conf

docker run -p 7777:7000 -d --name redisplus -v redisPlusData:/data -v /root/redis.conf:/etc/redis/redis.conf redis:5.0.10 redis-server /etc/redis/redis.conf 

安装ElasticSearch

注意：调高JVM线程数限制数量

#在centos窗口中，修改配置sysctl.conf
	$ vim /etc/sysctl.conf
#加入如下配置
	vm.max_map_count=262144 
#启用配置
	$ sysctl -p
#注：这一步是为了防止启动容器时，报出如下错误：
bootstrap checks failed max virtual memory areas vm.max_map_count [65530] likely too low, increase to at least [262144]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5KGr7aKi-1644203566952)(Docker_1.assets/image-20200602184321790.png)]

1. 将es拉到本地

$ docker pull elasticsearch:6.8.2

2. 启动es容器

$ docker run -d --name es -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms128m -Xmx128m"  elasticsearch:6.8.2

docker run -d --name es -p 9200:9200 -p 9300:9300  elasticsearch:6.8.2

#参数说明
-p  #将docker镜像中的端口号映射宿主机器端口号，宿主机器端口号:docker容器端口号 ，可写多个，如果多个端口号是连续的，可以直接用-连接，如：4560-4600:4560-4600
-v  #将docker镜像中的文件映射到宿主机器指定的文件，可以是文件夹，-v 宿主机文件:容器文件映射后可直接修改宿主机上的文件就可以改变docker中的配置，也可写多个。docker镜像中软件的配置文档默认在/usr/share”/{软件名}下
-e  #指定环境变量；

注意：根据自己情况来配置 -e ES_JAVA_OPTS="-Xms256m -Xmx256m" 不配置的话，启动会占用你的2G内存，反之，配置的话，启动则根据你配置的内存来分配。

3. 访问测试

访问地址：http://192.168.253.128:9200/

4.指定数据卷启动EleasticSearch容器

# 0.复制容器中data目录到宿主机中
$ docker cp 容器id:/usr/share/elasticsearch/data /root/es

# 1.运行ES容器 指定jvm内存大小并指定ik分词器位置
$ docker run -d --name es -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms128m -Xmx128m" -v /root/es/plugins:/usr/share/elasticsearch/plugins -v /root/es/data:/usr/share/elasticsearch/data elasticsearch:6.4.2

#eg:
docker run -d --name es -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms128m -Xmx128m" -v esPlugins:/usr/share/elasticsearch/plugins -v esData:/usr/share/elasticsearch/data -v esConfig:/usr/share/elasticsearch/config elasticsearch:6.8.0

4 安装IK分词器

4.1.下载对应版本的IK分词器

$ wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.2/elasticsearch-analysis-ik-6.8.2.zip

4.2.解压到plugins/elasticsearch文件夹中

#安装unzip
$ yum install -y unzip  
#使用unzip解压zip
$ unzip -d /var/lib/docker/volumes/esPlugins/_data/ elasticsearch-analysis-ik-6.8.2.zip

4.3.添加自定义扩展词和停用词

cd plugins/elasticsearch/config
vim IKAnalyzer.cfg.xml

<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">ext_dict.dic</entry>
	<!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords">ext_stopwords.dic</entry>
</properties>

4.4.创建配置文件

#在ik分词器目录下config目录中创建ext_dict.dic文件   编码一定要为UTF-8才能生效
$ vim ext_dict.dic 加入扩展词即可
#在ik分词器目录下config目录中创建ext_stopword.dic文件 
$ vim ext_stopwords.dic 加入停用词即可

4.5.将此容器提交成为一个新的镜像

$ docker commit -a="zcn" -m="with IKAnalyzer" 容器id zcn/elasticsearch:6.8.2

4.6.使用新生成的这个es镜像创建容器，并挂载数据卷

$ docker run -d --name es -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms128m -Xmx128m" -v /usr/local/IKAnalyzer:/usr/share/elasticsearch/plugins/elasticsearch/config zcn/elasticsearch:6.8.2

#参数说明
-p  #将docker镜像中的端口号映射宿主机器端口号，宿主机器端口号:docker容器端口号 ，可写多个，如果多个端口号是连续的，可以直接用-连接，如：4560-4600:4560-4600
-e ES_JAVA_OPTS="-Xms256m -Xmx256m"  #指定环境变量,设置初始堆内存和最大内存 也可以调整虚拟机内存
-v  #将docker镜像中的文件映射到宿主机器指定的文件，可以是文件夹，-v 宿主机文件:容器文件映射后可直接修改宿主机上的文件就可以改变docker中的配置，也可写多个。docker镜像中软件的配置文档默认在/usr/share”/{软件名}下.

5 安装kibana

5.1.下载kibana镜像到本地

$ docker pull kibana:6.8.2

5.2.启动kibana容器

$ docker run -d --name kibana -e ELASTICSEARCH_URL=http://192.168.253.128:9200 -p 5601:5601 kibana:6.8.2

5.3.访问kibana

访问地址：http://192.168.253.128:5601/

6.挂载配置文件启动

#进入kibana容器内部 
$ docker exec -it 容器内部/容器Id bash

#配置文件目录
/usr/share/kibana/config/

#挂载配置文件启动
$ docker run -d --name kibana -v kibanaConfig:/usr/share/kibana/config/ -p 5601:5601 kibana:6.8.2

docker run -d --name kibanaes -v kibanaConfig:/usr/share/kibana/config/ -p 5602:5601 kibana:6.8.0

7.测试数据

DELETE /ems

PUT /ems
{
  "mappings":{
    "emp":{
      "properties":{
        "name":{
          "type":"text",
           "analyzer": "ik_max_word",
           "search_analyzer": "ik_max_word"
        },
        "age":{
          "type":"integer"
        },
        "bir":{
          "type":"date"
        },
        "content":{
          "type":"text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_max_word"
        },
        "address":{
          "type":"keyword"
        }
      }
    }
  }
}



PUT /ems/emp/_bulk
  {"index":{}}
  {"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
  {"index":{}}
  {"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
  {"index":{}}
  {"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
  {"index":{}}
  {"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
  {"index":{}}
  {"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
  {"index":{}}
  {"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}


GET /ems/emp/_search
{
  "query":{
    "term":{
      "content":"框架"
    }
  },
  "highlight": {
    "pre_tags": [""],
    "post_tags": [""],
    "fields": {
      "*":{}
    }
  }
}

安装Nginx

1. 在DockerHub上查找nginx镜像

$ docker search nginx

2. 将Nginx拉到本地

$ docker pull nginx

3. 运行Nginx容器

$ docker run --name nginx-test -p 8080:80 -d nginx

#参数说明：
--name nginx-test：#容器名称。
-p 8080:80：       #端口进行映射，将本地 8080 端口映射到容器内部的 80 端口。
-d nginx：         #设置容器在在后台一直运行。

4.访问Nginx

访问地址：http://serverip:8080

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cIDCrlbR-1644203566952)(Docker_1.assets/docker-nginx6.png)]

4.进入容器

$ docker exec -it nginx-test /bin/bash
#查找目录:  whereis nginx
#配置文件:  /etc/nginx/nginx.conf

5.挂在nginx配置以及html到宿主机外部

#复制配置文件到宿主机
$ docker cp nginx-test(容器id|容器名称):/etc/nginx/nginx.conf 宿主机名录

#启动nginx并挂载数据卷
$ docker run -p 8080:80 -d --name nginx -v /root/nginx/nginx.conf:/etc/nginx/nginx.conf -v /root/nginx/html:/usr/share/nginx/html nginx

#eg:
docker run -p 8787:80 -d --name nginxt -v /root/niginxConfs/nginx.conf:/etc/nginx/nginx.conf -v nginxHtml:/usr/share/nginx/html nginx:1.19

---

安装RabbitMQ

1. 在DockerHub上查找RabbitMQ镜像

$ docker search rabbitmq

2. 将RabbitMQ拉到本地

$ docker pull rabbitmq:3.7.28-management

3. 运行RabbitMQ容器

$ docker run -d --hostname rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p 25672:25672 -p 15671:15671 -p 15672:15672 --name okong-rabbit rabbitmq:3.7.28-management

#参数说明：
-d      #后台运行容器；
–name   #指定容器名；
-p      #指定服务运行的端口（5672：应用访问端口；15672：控制台Web端口号）；
-v      #映射目录或文件；
–hostname #主机名（RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）；
-e      #指定环境变量；（RABBITMQ_DEFAULT_VHOST：默认虚拟机名；RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的密码）

4. 访问RabbitMQ

http://serverip:15672

登录账号：guest,密码：guest

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lsmuiUf5-1644203566953)(Docker_1.assets/Rabbitmq.png)]

安装MongoDB数据库

1. 在DockerHub上查找MongoDB镜像

$ docker search mongo

2. 将MongoDB拉到本地

$ docker pull mongo

3. 运行MongoDB容器

#无须权限
$ docker run -d -p 27017:27017 --name mymongo mongo

#查看mongo运行日志
$ docker logs -f mymongo

4. 进入mongodb容器

$ docker exec -it mymongo /bin/bash

#直接执行mongo命令进行操作

5.常见具有权限的容器

$ docker run --name  mymongo  -p 27017:27017  -d mongo --auth

6.进入容器配置用户名密码

mongo
use admin 选择admin库
#创建用户,此用户创建成功,则后续操作都需要用户认证
db.createUser({user:"root",pwd:"root",roles:[{role:'root',db:'admin'}]})   
exit

将mongoDB中数据目录映射到宿主机中

$ docker run -d -p 27017:27017 -v /root/mongo/data:/data/db --name mymongo mongo