首页 > 其他分享 >Docker容器的基本操作

Docker容器的基本操作

时间：2024-07-08 19:56:38浏览次数：15  
标签：容器 -- 宿主机 mysql 基本操作 Docker root docker

1 容器操作

  • 添加容器的两种方法

  • 会自动添加生成一个随机名字

image-20240620161312867

image-20240620161435511

# 启动docker
systemctl status docker
systemctl start docker

systemctl daemon-reload   # 重新加载docker配置
systemctl restart docker  # 重启docker

#1 镜像操作
	-docker search
	-docker pull
    -docker images  
    -docker rmi
 
#2 镜像运行，变成容器---》一个镜像可以运行处多个容器--》把一个容器当成一个虚拟机
	-操作系统
    -文件
    -软件
    -网络
    
# 3 运行出一个容器

1.1 run

# 1 把镜像运行成容器 
# 运行，如果镜像没有，会去远程仓库下载
docker run -id --name=centos7 centos:centos7
# -id  ：启动容器，不进入容器内部
# -it ：启动容器，进入容器内部
# --name：指定容器名字，容器名字不能重复，如果重复就报错，可以随便起
# centos:centos7：基于哪个镜像运行成容器



# 2 查看正在运行的容器
docker ps


# 直接输入pwd即可显示当前路径


# 3 执行：docker run -it  centos:centos7 
进入到容器内部，可以执行centos的命令，但是它是最精简的系统，很多命令可能没有，用的话需要安装
退出容器，回到宿主机：exit


# 4 容器需要创建然后运行
	-创建：create命令
    -运行：run
    -但是docker不需要create 直接用run即可 
# 5 #### 容器要运行，内部必须有个前台进程阻塞，否则容器就会停掉###

# 6 docker ps -a   #查看所有容器，包括停止的

# 7 删除容器
docker rm 容器名字/容器id

image-20240708193321536

1.2 run 时参数

# docker run 参数
    -i 表示运行容器
    -d 以守护式容器在后台运行，用这个参数创建出来的容器，命令行还在宿主机上，没有进入到容器内部
    -t 表示容器启动后会进入容器命令行。加入这参数后，容器创建就能登录进去。即分配一个伪终端。
    --name 指定容器名字，如果不指定，会随机一个名字
    -p 表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
    -v 表示目录映射关系（前者是宿主机目录，后者是容器的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上

几个小案例

# 1 启动一个centos容器并且进入,名字叫mycentos，在内部装个vim，然后退出
	1 docker run -id --name=mycentos centos:centos7
    2 在宿主机
    3 docker exec -it mycentos /bin/bash  # 新开了一个bash进程
    4 yum install vim -y
    5 exit
    6 容器停还是没有停？没有，因为容器运行时的 bash 进程没有结束
    
    
    
    
# 2 docker exec  命令
	在宿主机，链接容器，执行命令，把命令结果返回给宿主机
    docker exec 362a ls
    
    
# 3  进入到容器内部
	# 在容器上执行命令
	docker exec 容器名字/id  命令
    # 利用这个特性-->进入到容器内部
    docker exec -it 容器名字/id /bin/bash
    # 精简版进入 
    docker exec -it python sh
    # 退出，结束掉 /bin/bash
	exit

1.3 -v

image-20240708193335784

​ 当你在Docker中使用-v或--volume选项挂载宿主机的目录或文件到容器中时，确实会存在一种双向的文件共享关系，这可能会影响到宿主机上的内容。以下是对这种情况的详细解释：

  1. 文件或目录的挂载：使用-v选项，你可以将宿主机的文件或目录挂载到容器中的某个位置。这允许容器中的应用程序访问和操作这些文件或目录。
  2. 双向的文件共享：Docker的-v挂载是双向的，这意味着容器和宿主机之间的文件或目录是共享的。在容器中对挂载的文件或目录所做的任何更改都会反映到宿主机上，反之亦然。
  3. 内容变更的影响：
    • 如果你在容器中修改了挂载的文件或目录的内容，这些更改将同步到宿主机上的原始文件或目录。
    • 如果你在宿主机上修改了挂载的文件或目录的内容，这些更改也将同步到容器中的对应位置。
  4. 注意事项：
    • 由于这种双向同步的特性，你需要特别小心，确保不会意外地删除或修改重要的宿主机文件或目录。
    • 如果你需要保留宿主机上的原始内容，可以在挂载之前备份这些文件或目录。

先在宿主机创建一个

xx.txt文件

在到容器里面的cd jing路径 xx.txt 是先宿主机跟容器的共享

image-20240620202512278
在这里插入图片描述

  • 然后你返回宿主机也是一样的
docker run -id --name=centos7 -v /root/jing:/jing centos:centos7

具体来说：

宿主机上的 /root/jing 目录是源目录。
容器内的 /jing 路径是目标路径。
当容器运行时，你可以像在宿主机上操作 /root/jing 一样来访问和操作容器内的 /jing 目录中的文件。任何在容器内对 /jing 目录的修改都会反映到宿主机的 /root/jing 目录中，反之亦然。

# 1 -v 参数表示运行容器时，跟宿主机的文件目录做映射


#2 小案例
    # 运行出一个 centos77 容器，不进入， 做目录映射
    # 把宿主机的 /root/lqz文件夹  映射到 容器内部的 /lqz文件夹  容器如果没有文件夹会自动创建
    # -v可以写多个，可以是文件或文件夹
	
    # 宿主机进行创建
    1 cd # 回家 前提是你是root用户
    2 mkdir lqz  # 在root目录下创建lqz文件夹
    3 运行容器，做目录映射
    docker run -id --name=centos7 -v /root/lqz:/lqz centos:centos7
    4 在宿主机的 /root/lqz 下新建 xx.txt
    vim xx.txt

    5 来到容器内部：看这个文件在不在
    cat xx.txt

    6 他们是相互影响的：
        容器内部修改文件---》会影响外部
        外部修改文件---》影响内部



# 3 目录映射好处是，后期咱们部署django项目
	1 有个django容器，做好映射，代码放在宿主机上即可，以后更新了代码，只要重启容器，代码就是最新了
    2 运行mysql容器---》mysql配置文件，数据data目录，放在宿主机上做好映射
    	如果 mysql容器---》表数据，放到容器中---》如果删了容器---》数据库全没了
    	表数据，放在宿主机上---》把容器删除---》表数据还在----》再启动一个容器做好映射---》数据都还在

        
        
 
# 4 一次性删除

# 一次性删除所有容器
docker rm `docker ps -a -q`
# 一次性删除所有镜像
docker rmi `docker images -q`

1.4 -p

  • 创建mysql的环境变量

docker run -id --name=mysql5.7 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

​

yum install net-tools -y
netstat -nlp | grep 3307


# unbentu
sudo apt update
sudo apt install net-tools
# 验证是否安装成功！
dpkg -l | grep net-tools
netstat -nlp | grep 3308

image-20240620202647575

前提条件宿主机要用3307端口 这样不止容器可以访问 window也能进行访问

image-20240620205914945

mysql -h 10.0.0.100 -P 3307 -uroot -p
# mysql -h 宿主机ip地址 -P 宿主机的端口 -uroot -p

image-20240620210152929

image-20240620210507075

  • 这个也能实现文件之间的共享

image-20240620210728005

image-20240620211010042

dpkg -l | grep net-tools

image-20240620230528935

netstat -nlp | grep 3308

docker run -id --name=mysql5.7 -p 3308:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

docker ps

image-20240620230828414

docker exec -it mysql5.7 /bin/bash

mysql -u root -p

image-20240620231335939

image-20240620231346889

在这里插入图片描述

# 1  -p参数：端口映射  容器中启动一个mysql5.7 --》容器中的3306监听，宿主机3306没人监听，做端口映射后，宿主机的3306就被docker的这个容器监听了

# 2 小案例，运行一个mysql容器--》做端口映射
docker run -id --name=mysql5.7 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
#  -p： 启动mysql容器  -p 宿主机端口:容器端口
# -e ：启动的mysql的root密码是123456
# 以后台守护进程运行mysql容器，mysql的root用户密码是123456，宿主机和容器做了端口映射
	宿主机 3307 映射容器 3306

    
## 2.1 查看宿主机 3307端口占用情况

    #  netstat -nlp |grep 3307 查看本机80端口占用情况
    # 查看宿主机 3307端口占用情况
    yum install net-tools -y
    netstat -nlp | grep 3307 # 被docker占了

## 2.2 远程链接宿主机的3307端口
	以后访问宿主机3307端口就等于访问容器的3306端口

    # windoes机器可以远程链接 mysql
        -命令行链接：mysql -h 10.0.0.110 -P 3307 -uroot -p
        -Navicate： 链接，创建lqz数据库

    # 宿主机--》进入到容器内部--》进入到mysql，查看有没有创建lqz这个库
        docker exec -it mysql5.7 /bin/bash # 进入容器内部
        mysql -uroot  -p  # 进入mysql
        show databases;  # 查看所有数据库

1.5其他

docker start mysql5.7

image-20240620211727500

image-20240620211857319

  • 拷贝

image-20240620213729119

  • 查看容器ip地址

image-20240620214026409

# 在主机执行
#1 启动容器
	docker start 容器id 
#2 停止容器
	docker stop 容器id


    # 在主机里面执行
#3  mysql的容器底层的操作系统是 debian 装软件需要用 
    apt-get update
    apt-get install vim -y



#4  文件拷贝(宿主机执行)
	# 容器的文件copy到宿主机上（不是在容器内执行）
    docker cp 容器名称:容器目录 需要拷贝的文件或目录
    docker cp  0a9633190cb9:/xx.txt /root/lqz/lqz.txt
    
    # 宿主机的文件copy到容器中
    docker cp 需要拷贝的文件或目录 容器名称:容器目录
    docker cp /root/lqz/xx.txt  0a9633190cb9:/xx.txt

        
        
    
   # 主机里面执行
# 5 查看容器IP地址    
	docker inspect 容器名称  # 查看容器的详细描述，很多
    docker inspect ea5f3c9ee99a --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
    
    
# 6 在多个容器之间是可以ping通的(容器和宿主机也可以)
    # python:172.17.0.3

    # mysql5.7:172.17.0.2

    # 宿主机--》ping 它俩
    # 容器--》容器
    apt-get install iputils-ping
     ping 172.17.0.2

    
    
    
    
# 7 删除容器（删除已停止的容器）
	docker rm 容器id  
    docker rm `docker ps -a -q`
    # 加个 -f 强制删除
    docker rm -f 7342e5435963

    
    

    

    
# 8 无状态的服务（在容器中尽量运行无状态的服务）
    -mysql reids   有状态，运行过程中产生数据，保存，容器删除，数据就没了
    -uwsgi+django  无状态的服务
    
  

    
    
    
# 9 补充
	1 ip地址  ip 
    	10.0.88.110
        10.0.0.111
        10.0.0.1
        10.0.11.1
    2 子网掩码 mask
    	255.255.0.0
        
    3 网关 gatway
    	10.0.0.1

2 应用部署

unbantu 要注意的就是在因为我用的是jingyi用户所以创建的文件是在/ 根目录下的

2.1 mysql 部署

image-20240620214211686

#0 dokcer 中部署mysql，以后不需要在宿主机上装mysql
	

#1  没有做目录映射---》配置文件--》表数据都在容器中---》一旦删除--》所有都没了
docker run -di --name=mysql -p 3308:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7


# 2 做目录(配置文件和数据文件)和端口映射

# 做目录映射：data文件，配置文件
# 创建文件夹
mkdir /mysql
mkdir /mysql/conf.d
mkdir /mysql/data/
vi /mysql/my.cnf
[client]
default-character-set=utf8
[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000

docker run  -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3306:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7      
        
     
    
# 创建库，创建表，插入数据

# 关闭容器，删除容器，myslq的容器没了，但是数据在宿主机上放着
 docker stop mysql2
 docker rm mysql2
##docker rm mysql -f  容器之间删了

# 再运行起一个容器，做好目录映射，数据都回来了
docker run  -id -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3307:3306 --name mysql2 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7 



# 补充  -e参数--》环境变量
	-不同镜像提供不同参数
    -传入后放入环境变量
    echo $MYSQL_ROOT_PASSWORD
  1. docker run：这是 Docker 的命令，用于从指定的镜像启动一个新的容器。
  2. -di：这实际上是两个参数 -d 和 -i 的简写，但通常 -i 与 -t（分配一个伪终端）一起使用。在这里，-d 是正确的，它表示“分离模式”（detached mode），即容器在后台运行。但 -i 是不必要的，并且可能会被误解，所以你应该使用 -d 而不是 -di。
  3. -v /mysql/data/:/var/lib/mysql：这是一个卷（volume）映射。它将宿主机上的 /mysql/data/ 目录映射到容器内的 /var/lib/mysql 目录。这意味着容器内的 MySQL 数据库文件将存储在宿主机的 /mysql/data/ 目录下，这样即使容器被删除，数据仍然保留。
  4. -v /mysql/conf.d:/etc/mysql/conf.d：另一个卷映射。它将宿主机上的 /mysql/conf.d 目录映射到容器内的 /etc/mysql/conf.d 目录。这允许你在宿主机上放置自定义的 MySQL 配置文件，并在容器启动时使用它们。
  5. -v /mysql/my.cnf:/etc/mysql/my.cnf：与上面的类似，这也是一个卷映射。它将宿主机上的 /mysql/my.cnf 文件映射到容器内的 /etc/mysql/my.cnf 文件。这是 MySQL 的主要配置文件。
  6. -p 3306:3306：端口映射。它将宿主机的 3306 端口映射到容器内的 3306 端口。这样，当你尝试连接到宿主机的 3306 端口时，实际上是在连接到容器内的 MySQL 服务。
  7. –name mysql5.7：为新容器指定一个名称，这里是 mysql5.7。
  8. -e MYSQL_ROOT_PASSWORD=123456：设置环境变量。在这里，它设置了 MySQL 的 root 用户的密码为 123456。
  9. mysql:5.7：这是你要从中启动容器的 Docker 镜像的名称和标签。这里，你正在使用官方的 MySQL 5.7 镜像。

​ 所以，总的来说，条命令从 mysql:5.7 镜像启动了一个新的 Docker 容器，设置了 MySQL 的 root 密码，并配置了数据、配置和主要配置文件的卷映射。

image-20240620235531457

image-20240620235746434

2.2 redis部署

#1  拉取redis镜像
docker pull redis  #最新
mkdir /root/data
vim /root/redis.conf

bind 0.0.0.0
daemonize NO
protected-mode yes
requirepass 123456



# 运行
#启动容器时，运行的命令是什么 redis-server /etc/redis/redis.conf

docker run -id  -p 6379:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis  redis-server /etc/redis/redis.conf
       
    
# 在容器运行时，可以自己定制运行命名 举例：docker run -id centos:centos7 ls

  docker exec -it redis /bin/bash
  # 启动redis
     redis-cli
# 验证密码  
auth 123456 
# 查看字段
get name
    
# 远程链接redis操作

在这里插入图片描述

image-20240620220803389

2.3 nginx部署

image-20240620234932231

在这里插入图片描述

# 拉取nginx镜像
docker pull nginx


cd 
mkdir /root/html
cd /root/html/
vi index.html
# run起容器
# docker run -id --name nginx -p 80:80 nginx
    
# /usr/share/nginx/html
docker run -id --name nginx1 -p 8008:80 -v /root/html:/usr/share/nginx/html nginx
# 以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的

标签：容器,--,宿主机,mysql,基本操作,Docker,root,docker
From： https://blog.csdn.net/m0_58310590/article/details/140259797

相关文章

  • 构建自己的docker基础镜像
    构建自己的docker基础镜像构建一个完全定制的基础镜像意味着您需要从一个非常小的镜像（例如scratch镜像）开始，然后逐步添加您需要的所有内容。scratch镜像是一个空白的基础镜像，可以用来创建高度定制的容器环境。创建一个基础镜像构建debian基础镜像准备根文件系统：要构......
  • 常用 Docker 命令和配置指南 新手几乎够用 老手持续更新
    容器管理命令查看容器：查看所有已启动/未启动的容器：dockerps-a查看所有已启动的容器：dockerps启动和停止容器：启动容器：dockerstart容器ID停止容器：dockerstop容器ID重启容器：dockerrestart容器ID删除容器：删除容器：dockerrm容器ID镜像管理命令......
  • Docker基本操作
    1.简介Docker是一个开源的应用容器引擎，它允许开发者打包他们的应用以及应用的依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。Docker的主要用途包括：简化配置：Docker可以确保应用的运......
  • Docker部署Django+MySQL+Redis+Nginx+uWSGI+Celery(超详细)
    一、知识储备经过我们之前学习的Docker相关知识，现在我们来进行实战，以下介绍如何通过DockerCompose部署Django项目：先前知识:Docker学习笔记（一）概念理解-CSDN博客Docker学习笔记（二）镜像、容器、仓库相关命令操作-CSDN博客Docker学习笔记（三）Dockerfile-CSDN博客DockerCompose......
  • Docker安装命令
    事先声明-对于命令直接粘进去执行就可以Docker分为CE和EE两大版本。CE即社区版（免费，支持周期7个月），EE即企业版，强调安全，付费使用，支持周期24个月。DockerCE分为stabletest和nightly三个更新频道。最重要一点：DockerCE支持64位版本CentOS7，并且要求内核版本......
  • docker-compose vs docker-stack
    docker-composevsdocker-stack都是docker两个容器编排工具，docker-compose是属于第三方容器编排工具需要单独安装，docker-stack是docker内置容器编排工具。docker-compose一般配合K8S使用，目前要容器管理方面K8S有着比较明显的优势，所以docker-compose目前比较流行。docker-stac......
  • 使用ruri快速构建跨架构chroot容器
    在开发过程中，我们偶尔会用到跨架构Linux容器。ruri全称“轻量型，用户友好的Linux容器实现”，是一个1M左右大小的Linux容器实现，提供了一系列功能选项，致力于成为更加强大且安全的chroot命令替换。我们以在x86_64系统下运行arm64的Ubuntu容器为例：确认binfmt_misc支持：~$cat/proc/f......
  • 介绍 Docker 的基本概念和优势，以及在应用程序开发中的实际应用。
    Docker是一种开源的容器化平台，用于构建、部署和管理应用程序。它采用了轻量级的虚拟化技术，允许将应用程序及其依赖包装在一个独立的容器中，以便于在不同的环境中运行。Docker的主要优势包括：1.轻量级和快速启动：Docker容器与传统虚拟化相比更轻量级，可以在几秒钟内启动和停止。......
  • 随着云计算和容器技术的广泛应用，如何在这些环境中有效地运用 Shell 进行自动化部署和
    在云计算和容器技术的环境中，Shell脚本可以被用于自动化部署和管理任务。下面是一些在这些环境中有效使用Shell进行自动化部署和管理的方法：在云环境中，使用云服务提供商的API进行自动化管理。例如，使用命令行工具或SDK来管理云资源、启动虚拟机、创建存储等。将这些A......
  • STL复习-序列式容器和容器适配器部分
    STL复习1.常见的容器如何介绍这些容器，分别从常见接口，迭代器类型，底层实现序列式容器stringstring严格来说不属于stl，它是属于C++标准库**底层实现：**string本质是char类型的顺序表，因为不同编译器下的具体实现不同，这里只提供一个我的简答框架classstring{public:......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99