Docker

Docker

1 Docker简介

1.1 什么是虚拟化

​ 在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态更好的方式来应用这些资源。这些资源的新虚拟部份是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。

​ 在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而最大化的利用物理硬件   对资源充分利用

​ 虚拟化技术种类很多，例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等等。

1.2 什么是Docker

​ Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的 Go 语言实现。 项目后来加入了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在 GitHub 上进行维护。

​ Docker 自开源后受到广泛的关注和讨论，以至于 dotCloud 公司后来都改名为 Docker Inc。Redhat 已经在其 RHEL6.5 中集中支持 Docker；Google 也在其 PaaS 产品中广泛应用。

​ Docker 项目的目标是实现轻量级的操作系统虚拟化解决方案。 Docker 的基础是 Linux 容器（LXC）等技术。

​ 在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的容器就像操作一个快速轻量级的虚拟机一样简单。

为什么选择Docker?

（1）上手快。

​ 用户只需要几分钟，就可以把自己的程序“Docker化”。Docker依赖于“写时复制”（copy-on-write）模型，使修改应用程序也非常迅速，可以说达到“随心所致，代码即改”的境界。

随后，就可以创建容器来运行应用程序了。大多数Docker容器只需要不到1秒中即可启动。由于去除了管理程序的开销，Docker容器拥有很高的性能，同时同一台宿主机中也可以运行更多的容器，使用户尽可能的充分利用系统资源。

（2）职责的逻辑分类

​ 使用Docker，开发人员只需要关心容器中运行的应用程序，而运维人员只需要关心如何管理容器。Docker设计的目的就是要加强开发人员写代码的开发环境与应用程序要部署的生产环境一致性。从而降低那种“开发时一切正常，肯定是运维的问题（测试环境都是正常的，上线后出了问题就归结为肯定是运维的问题）”

（3）快速高效的开发生命周期

​ Docker的目标之一就是缩短代码从开发、测试到部署、上线运行的周期，让你的应用程序具备可移植性，易于构建，并易于协作。（通俗一点说，Docker就像一个盒子，里面可以装很多物件，如果需要这些物件的可以直接将该大盒子拿走，而不需要从该盒子中一件件的取。）

（4）鼓励使用面向服务的架构

​ Docker还鼓励面向服务的体系结构和微服务架构。Docker推荐单个容器只运行一个应用程序或进程，这样就形成了一个分布式的应用程序模型，在这种模型下，应用程序或者服务都可以表示为一系列内部互联的容器，从而使分布式部署应用程序，扩展或调试应用程序都变得非常简单，同时也提高了程序的内省性。（当然，可以在一个容器中运行多个应用程序）

1.3 容器与虚拟机比较

​ 下面的图片比较了 Docker 和传统虚拟化方式的不同之处，可见容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统方式则是在硬件层面实现。

与传统的虚拟机相比，Docker优势体现为启动速度快、占用体积小。

1.4 Docker 组件

1.4.1 Docker服务器与客户端

​ Docker是一个客户端-服务器（C/S）架构程序。Docker客户端只需要向Docker服务器或者守护进程发出请求，服务器或者守护进程将完成所有工作并返回结果。Docker提供了一个命令行工具Docker以及一整套RESTful API。你可以在同一台宿主机上运行Docker守护进程和客户端，也可以从本地的Docker客户端连接到运行在另一台宿主机上的远程Docker守护进程。

1.4.2 Docker镜像与容器

​ 镜像是构建Docker的基石。用户基于镜像来运行自己的容器。镜像也是Docker生命周期中的“构建”部分。镜像是基于联合文件系统的一种层式结构，由一系列指令一步一步构建出来。例如：

添加一个文件；

执行一个命令；

打开一个窗口。

也可以将镜像当作容器的“源代码”。镜像体积很小，非常“便携”，易于分享、存储和更新。

​ Docker可以帮助你构建和部署容器，你只需要把自己的应用程序或者服务打包放进容器即可。容器是基于镜像启动起来的，容器中可以运行一个或多个进程。我们可以认为，镜像是Docker生命周期中的构建或者打包阶段，而容器则是启动或者执行阶段。  容器基于镜像启动，一旦容器启动完成后，我们就可以登录到容器中安装自己需要的软件或者服务。

所以Docker容器就是：

​ 一个镜像格式；

​ 一些列标准操作；

​ 一个执行环境。

​ Docker借鉴了标准集装箱的概念。标准集装箱将货物运往世界各地，Docker将这个模型运用到自己的设计中，唯一不同的是：集装箱运输货物，而Docker运输软件。

和集装箱一样，Docker在执行上述操作时，并不关心容器中到底装了什么，它不管是web服务器，还是数据库，或者是应用程序服务器什么的。所有的容器都按照相同的方式将内容“装载”进去。

Docker也不关心你要把容器运到何方：我们可以在自己的笔记本中构建容器，上传到Registry，然后下载到一个物理的或者虚拟的服务器来测试，在把容器部署到具体的主机中。像标准集装箱一样，Docker容器方便替换，可以叠加，易于分发，并且尽量通用。

1.4.3 Registry（注册中心）

​ Docker用Registry来保存用户构建的镜像。Registry分为公共和私有两种。Docker公司运营公共的Registry叫做Docker Hub。用户可以在Docker Hub注册账号，分享并保存自己的镜像（说明：在Docker Hub下载镜像巨慢，可以自己构建私有的Registry）。

​ https://hub.docker.com/

2 Docker安装与启动

2.1 安装Docker

​ Docker官方建议在Ubuntu中安装，因为Docker是基于Ubuntu发布的，而且一般Docker出现的问题Ubuntu是最先更新或者打补丁的。在很多版本的CentOS中是不支持更新最新的一些补丁包的。

​ 由于我们学习的环境都使用的是CentOS，因此这里我们将Docker安装到CentOS上。注意：这里建议安装在CentOS7.x以上的版本，在CentOS6.x的版本中，安装前需要安装其他很多的环境而且Docker很多补丁不支持更新。

​ 请直接挂载课程配套的Centos7.x镜像

（1）yum 包更新到最新

# yum remove docker docker-common  docker-selinux docker-engine
# rm -rf /var/lib/docker

sudo yum update

（2）安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的

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

（3）设置yum源为阿里云

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

（4）安装docker

sudo yum install docker-ce

（5）安装后查看docker版本

docker -v

2.2 设置ustc的镜像

ustc是老牌的linux镜像服务提供者了，还在遥远的ubuntu 5.04版本的时候就在用。ustc的docker镜像加速器速度很快。ustc docker mirror的优势之一就是不需要注册，是真正的公共服务。

https://lug.ustc.edu.cn/wiki/mirrors/help/docker

编辑该文件：

vi /etc/docker/daemon.json  

在该文件中输入如下内容：

{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}

2.3 Docker的启动与停止

systemctl命令是系统服务管理器指令

启动docker：

systemctl start docker

停止docker：

systemctl stop docker

重启docker：

systemctl restart docker

查看docker状态：

systemctl status docker

开机启动：

systemctl enable docker

查看docker概要信息

docker info

查看docker帮助文档

docker --help

3 常用命令

3.1 镜像相关命令

3.1.1 查看镜像

docker images

REPOSITORY：镜像名称

TAG：镜像标签

IMAGE ID：镜像ID

CREATED：镜像的创建日期（不是获取该镜像的日期）

SIZE：镜像大小

这些镜像都是存储在Docker宿主机的/var/lib/docker目录下

3.1.2 搜索镜像

如果你需要从网络中查找需要的镜像，可以通过以下命令搜索

docker search 镜像名称

NAME：仓库名称

DESCRIPTION：镜像描述

STARS：用户评价，反应一个镜像的受欢迎程度

OFFICIAL：是否官方

AUTOMATED：自动构建，表示该镜像由Docker Hub自动构建流程创建的

3.1.3 拉取镜像

拉取镜像就是从中央仓库中下载镜像到本地

docker pull 镜像名称

例如，我要下载centos7镜像

docker pull centos:7

3.1.4 删除镜像

按镜像ID删除镜像

docker rmi 镜像ID

删除所有镜像

docker rmi `docker images -q`

3.2 容器相关命令

3.2.1 查看容器

查看正在运行的容器

docker ps

查看所有容器

docker ps –a

查看最后一次运行的容器

docker ps –l

查看停止的容器

docker ps -f status=exited

3.2.2 创建与启动容器

创建容器常用的参数说明：

创建容器命令：docker run

-i：表示运行容器

-t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。

--name :为创建的容器命名。

-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。

-d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）。

-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射

（1）交互式方式创建容器

docker run -it --name=容器名称 镜像名称:标签 /bin/bash

这时我们通过ps命令查看，发现可以看到启动的容器，状态为启动状态

退出当前容器

exit

（2）守护式方式创建容器：

docker run -di --name=容器名称 镜像名称:标签

登录守护式容器方式：

docker exec -it 容器名称 (或者容器ID)  /bin/bash

3.2.3 停止与启动容器

停止容器：

docker stop 容器名称（或者容器ID）

启动容器：

docker start 容器名称（或者容器ID）

3.2.4 文件拷贝

如果我们需要将文件拷贝到容器内可以使用cp命令

docker cp 需要拷贝的文件或目录 容器名称:容器目录

也可以将文件从容器内拷贝出来

docker cp 容器名称:容器目录 需要拷贝的文件或目录

3.2.5 目录挂载

我们可以在创建容器的时候，将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器。
创建容器 添加-v参数 后边为 宿主机目录:容器目录，例如：

docker run -di -v /usr/local/myhtml:/usr/local/myhtml --name=mycentos3 centos:7

如果你共享的是多级的目录，可能会出现权限不足的提示。

这是因为CentOS7中的安全模块selinux把权限禁掉了，我们需要添加参数 --privileged=true 来解决挂载的目录没有权限的问题

3.2.6 查看容器IP地址

我们可以通过以下命令查看容器运行的各种数据

docker inspect 容器名称（容器ID） 

也可以直接执行下面的命令直接输出IP地址

docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

3.2.7 删除容器

删除指定的容器：

docker rm 容器名称（容器ID）

4 应用部署

4.1 MySQL部署

（1）拉取mysql镜像

docker pull centos/mysql-57-centos7

（2）创建容器

docker run -di --name=tensquare_mysql -p 33306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

-p 代表端口映射，格式为  宿主机映射端口:容器运行端口

-e 代表添加环境变量  MYSQL_ROOT_PASSWORD 是root用户的登陆密码

（3）远程登录mysql

连接宿主机的IP ,指定端口为33306

4.2 Nginx部署

（1）拉取镜像

docker pull nginx

（2）创建Nginx容器

docker run -di --name=mynginx -p 80:80 nginx

4.3 Redis部署

（1）拉取镜像

docker pull redis

（2）创建容器

docker run -di --name=myredis -p 6379:6379 redis

bind 0.0.0.0
daemonize NO
protected-mode no
requirepass 123456


docker run -p 6379:6379 --name redis_6379 -v /home/docker/reids/conf/redis.conf:/etc/redis/redis.conf -v /home/docker/reids/data:/data -d redis:alpine3.11 redis-server /etc/redis/redis.conf --appendonly yes

5 迁移与备份

5.1 容器保存为镜像

我们可以通过以下命令将容器保存为镜像

docker commit mynginx mynginx_i

5.2 镜像备份

我们可以通过以下命令将镜像保存为tar 文件

docker  save -o mynginx.tar mynginx_i

5.3 镜像恢复与迁移

首先我们先删除掉mynginx_img镜像 然后执行此命令进行恢复

docker load -i mynginx.tar

-i 输入的文件

执行后再次查看镜像，可以看到镜像已经恢复

6 Dockerfile

6.1 什么是Dockerfile

Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。

1、对于开发人员：可以为开发团队提供一个完全一致的开发环境；
2、对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了；
3、对于运维人员：在部署时，可以实现应用的无缝移植。

6.2 常用命令

命令	作用
FROM image_name:tag	定义了使用哪个基础镜像启动构建流程
MAINTAINER user_name	声明镜像的创建者
ENV key value	设置环境变量 (可以写多条)
RUN command	是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file	将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file	和ADD相似，但是如果有压缩文件并不能解压
WORKDIR path_dir	设置工作目录

6.3 使用脚本创建镜像

步骤：

（1）创建目录

mkdir –p /usr/local/dockerdjango

（2）下载jdk-8u171-linux-x64.tar.gz并上传到服务器（虚拟机）中的/usr/local/dockerjdk8目录

（3）创建文件Dockerfile vi Dockerfile

#依赖镜像名称和ID
FROM centos:7
#指定镜像创建者信息
MAINTAINER TEST
#切换工作目录
WORKDIR /usr

（4）执行命令构建镜像

docker build -t='django2.0' .

注意后边的空格和点，不要省略

（5）查看镜像是否建立完成

docker images

7 Docker私有仓库

7.1 私有仓库搭建与配置

（1）拉取私有仓库镜像（此步省略）

docker pull registry

（2）启动私有仓库容器

docker run -di --name=registry -p 5000:5000 registry

（3）打开浏览器 输入地址http://192.168.1.12:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空

（4）修改daemon.json

vi /etc/docker/daemon.json

添加以下内容，保存退出。

{"insecure-registries":["192.168.1.12:5000"]} 

此步用于让 docker信任私有仓库地址

（5）重启docker 服务

systemctl restart docker

7.2 镜像上传至私有仓库

（1）标记此镜像为私有仓库的镜像

docker tag django2.0 192.168.1.12:5000/django2.0

（2）再次启动私服容器

docker start registry

（3）上传标记的镜像

docker push 192.168.1.12:5000/django2.0

### 基本
个人开发环境-->公司内部服务器环境-->测试环境-->预发布环境-->生产环境

单点部署：容灾性低，不够健壮。 
用户-->Nginx(vue)-->uWSGI_drf-->mysql-->redis-->elasticsearch

分布式集群架构：可用性高，容灾性强，费用不低，有较高的维护成本。
用户-->Nginx反向代理理负载均衡192.168.233.100-->(前端:vue1, vue2)-->Nginx反向代理负载均衡192.168.233.103-->(后端:uWSGI_Django1,uWSGI_Django2,uWSGI_Django3)-->mysql(mysql_master, mysql_slave1, mysql_slave2)-->redis(master,slave1,slave2,sentinel1,sentinel2,sentinel3)-->elasticsearch(node1,node2...)

并发瓶颈：(QPS【每秒请求数】ICP（工信部）)
    短板原理[水桶原理]
    1. 带宽：20M/40kb
    2. 处理并发的能力[web服务器], nginx 客户端静态资源代理-> 4C4M上3-4W，Uwsgi/Gunicorn/Uvincorn -> 3000-5000
    3. 数据库查询能力：
    mysql 默认最大连接数151个，最高可以达到16384个，处理QPS的能力，默认大概1000次/s 。    
    show variables like '%max_connections%';

    redis 默认是1W的连接数，最高可以配置到10W，并发处理能力与连接数有关，默认1W连接的话，5W/s。
    CONFIG GET maxclients

    4. 物理服务器本身的承载能力[8核16G起步...]  【腾讯云、华为云、阿里云、网易云、百度云等等，找新手礼包】
当前项目要完整的跑起来，务必购买的服务器配置：2C4G2M

ab工具进行压测，根据短板原理得到系统的并发处理数的乐观数据
```python
# 安装命令：
# sudo apt install apache2-utils

# 基本使用命令
ab -n 1000 -c 100 -w https://www.luffycity.com/ >> ~/ab.html
# -n 表示本次压测的总请求执行数
# -c 表示本次压测的并发数
# -w 表示以HTML格式输出压测结果

# ab命令会创建多个并发访问线程，模拟多个访问者同时对某一URL地址进行访问。它的测试目标是基于URL的，因此，它既可以用来测试apache的负载压力，也可以测试nginx、lighthttp、tomcat、IIS等其它Web服务器的压力。
```

通过scp上传代码到线上服务器
```python
# scp 本地路径 账号@远程地址:线上路径 
# 本地Ubuntu终端
cd ~/Desktop/luffycity/luffycityweb
tar -zcf luffycityweb.tar.gz dist
scp ~/Desktop/luffycity/luffycityweb/luffycityweb.tar.gz root@114.115.200.1:/home/

# 线上服务器操作[远程部署终端]
cd /home
tar -zxf luffycityweb.tar.gz
mkdir /home/luffycity
mv /home/dist /home/luffycity/luffycityweb
```




### docker
镜像:
docker images
docker pull ubuntu:20.04
docker rmi ubuntu:20.04
sudo docker save -o 文件名.tar.gz  镜像名:版本号
sudo docker load -i 文件名.tar.gz
sudo docker login -u 账号名
sudo docker push 镜像名称/镜像ID:版本号
sudo docker commit <容器名称/容器ID>  <新镜像名:镜像自定义版本>

容器:
sudo docker container ls                      # 所有正在启动运行的容器
sudo docker container ls --all                # 所有容器[不管是否在启动运行中]
sudo docker start  <容器名称/容器ID>
sudo docker start <容器名称/容器ID>  <容器名称/容器ID> <容器名称/容器ID>
sudo docker stop <容器名称/容器ID>  <容器名称/容器ID>
sudo docker kill <容器名称/容器ID>  <容器名称/容器ID>
sudo docker rm <容器名称/容器ID>  <容器名称/容器ID>

sudo docker exec -it <容器名称/容器ID>  <第一个命令>

sudo docker cp <物理机路径> <容器名称/容器ID>:<容器路径>
sudo docker cp <容器名称/容器ID>:<容器路径> <物理机路径>

```python
##### docker run的参数选项
sudo docker run <参数选项>  <镜像名称:镜像版本> <容器启动后的第一个命令>
-t    表示容器启动后会进入其命令行终端
-i     表示以“交互模式”运行容器
--name  表示设置容器的名称，注意容器名是唯一的，尽量遵循python变量名的规范。
-v    目录影射，相当于把容器外部的物理机的目录与容器内部的目录实现共享，改了里面相当于改了外面
-p    端口影射，把物理机的一个端口和容器内部的端口进行绑定。访问了物理机的端口相当于访问了容器的对应端口
-e    设置环境变量，在部分容器中，需要设置环境变量时使用到
--restart=always    设置容器随着docker开机自启，docker/podman中创建的容器默认是不会开机自启，同时podman是没有这个选项的。
--network=host      设置网络模式，与-p冲突，一般设置-p以后不要设置--network
-d   创建一个守护式容器在后台运行(这样创建容器后不会自动登录容器内部的，需要使用docker exec -it 命令才能进入容器内部)
```

在远程部署终端启动容器服务
cd /home/luffycity
chmod 777 /home/luffycity/data/elastic

docker-compose -f docker-compose.yml up -d
docker-compose -f docker-compose.yml down
监控docker-compose的所有容器运行的日志信息
docker-compose logs -f

等待1分钟后给elasticsearch构建索引
docker exec -it api1 python manage.py rebuild_index

测试mysql:
docker exec -it mysql_master mysql -uroot -proot2022
use luffycity
show tables;

测试redis:
docker exec -it redis_master redis-cli -a 123456

postman中测试访问: (es索引的生成是要结合django项目的ORM来生成)
post http://114.115.200.1:9200/_analyze?pretty
{
  "analyzer": "ik_max_word",
  "text": "我是中国人，我来自北京。"
}

启动uwsgi服务器，必须在uwsgi.ini配置文件所在的目录中运行下面的命令(注意，在本地环境中必须先把runserver关闭)
启动uwsgi服务器
uwsgi --ini uwsgi.ini
停止uwsgi服务器，还可以通过使用kill命令停止
uwsgi --stop uwsgi.pid



## docker
0 各种软件用什么语言写的
    zabbix（监控软件）：php
    ansible（批量管理主机，执行命令,无angent）：python
    openstack（云计算，管理虚拟机）：python
    jekins（ci/di）：自动化部署，java
    salstack(批量管理主机，执行命令，有angent):python
    普罗米修斯（Prometheus，监控）：go写的
    docker：go
    k8s：go

1 什么是虚拟化?
    -vmware,kvm,openstack,docker,k8s
    -云服务器：vmware,kvm虚拟化出来的，vmware,kvm直接在硬件或者操作系统上安装
    -阿里云，腾讯云：opensatck，阿里飞天，用来管理虚拟化出来的操作系统
    -docker：进程级别的隔离，装在虚拟机，云服务器上，一个云服务上开业跑出成几百个docker容器，成百上千的服务器上，就会有个上万个容器
    -k8s：不同机器的上万个容器如何管理
    
    -虚拟化：打破实体结构间的不可切割的障碍
    
2 什么是Docker？
    - Go语言实现，开源出来，很多人用
    - docker-ce（免费），docker-ee（收费）
    - 通过go语言对lxc技术的一个封装
    -上手快，简单
3 容器与虚拟机比较
    -docker不需要虚拟硬件和操作系统，轻量级，占用体积小，启动快
    
4 Docker是一个客户端-服务器（C/S）架构程序（mysql，redis都是cs架构），整套RESTful API

5 docker非常重要的概念：镜像（image）与容器（container）
    有了镜像---》镜像运行起来是容器（真正的执行单位）
    面向对象的类     对象
6 镜像是从哪里来的？
    -镜像就是一堆文件
    -从远程仓库获取（拉取）    

#### centos上安装docker（必须7.0以上）
```python
# 6.8安装docker，自行搜索，升级内核版本
# docker是在linux3.1以上内核中写出来的，在乌班图下开发的，docker的新特性，乌班图先看到，
# 官方建议docker运行在centos7 以上的系统

#####安装
0 卸载
yum remove docker docker-common  docker-selinux docker-engine
rm -rf /var/lib/docker

1 更新yum
yum update
2 安装需要的软件包， yum-util 
yum install -y yum-utils device-mapper-persistent-data lvm2
3 执行（向你的yum源，增加一条记录）
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4 安装 
yum install docker-ce

5 验证安装（查看版本）
docker -v  
~]# docker -v  （19年03月12日发布）
# 自从分了docker-ce和docker-ee以后，以年份命名版本
Docker version 19.03.12, build 48a66213fe

6 启动docker服务
systemctl start docker

7 停止docker服务，重启docker服务,查看docker状态
systemctl stop docker
systemctl restart docker
systemctl status docker

8 开机启动    
systemctl enable docker

9 查看概要信息
docker info（你可能写了一个管理docker的运维平台）
```

#### docker使用 
systemctl start docker

```python
######################### 远程仓库  #################
注册，登录 https://hub.docker.com/
你可以上传镜像（类似于github），你把你制作的镜像传上去，别人可以下载使用

配置加速（之前去https://hub.docker.com/），阿里云，清华，做了一个备份，配置好以后，再拉镜像会去国内地址拉取
第一步：vi /etc/docker/daemon.json  
第二步：
{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}
######################### 镜像操作  #################
-1 第一个hello-world（没有任何意义）
    docker run hello-world
    1 客户端连到服务端，服务下载了hello-world镜像
    2 通过镜像跑起容器来
    3 容器输出一些东西，通过服务端发送给客户端，客户端展示在窗口里了

0 查找镜像
    方式一：https://hub.docker.com/ 点点点搜索（你用这种）
    方式二：docker search 
1 拉取镜像 
    docker pull hello-world  最新版本latest
    docker pull hello-world:nanoserver
2 查看机器上有哪些镜像
     docker images
    REPOSITORY  TAG   IMAGE ID   CREATED   SIZE
    镜像名字      版本   id号       创建时间   大小
3 删除镜像
    docker rmi 镜像名字/id号（如果还有基于这个镜像的容器，是不允许删除镜像的，先删除容器，再删除images）
    docker rmi -f 镜像名字/id号   强制删除

4 镜像是什么？
    -就是一堆文件，这堆文件通过docker跑起来，就是容器，你现在就把他当成，一个操作系统内跑了这个软件（centos+redis）
    -假设centos7的镜像跑起来，容器你就当成在你宿主机上跑了一个centos7的操作系统（虚拟机）
    
    
5 补充（了解）
    docker image --help
    docker image inspect 46ff56815c7c
    docker image ls
    docker image rm

6 拉取python3.6镜像，redis最新镜像，mysql5.7镜像
    docker pull python:3.6
    docker pull redis
    docker pull mysql:5.7
    docker pull centos:centos7
    docker pull nginx

######################### 应用部署  #################
# 在容器内部署mysql
# -e表示环境变量
docker run -di --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
# 官方提供的
docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
        
# 在容器内部署redis
docker run -di --name=redis -p 6379:6379 redis:latest
        
# 在容器内部署nginx
docker run -di --name=nginx -p 80:80 nginx

# 纯净的centos7镜像--》容器---》装python3.6

######################### 容器操作  #################
1 删除容器
 docker rm 容器名字/容器id
 docker rm -f 容器名字/容器id   强制删除
2 启动并运行容器
    # 通过centos:centos7镜像，创建一个容器名字叫mycentos，并且把它运行起来
    docker run -di --name=mycentos centos:centos7
    打印出容器的id号
3 查看机器上正在运行的容器
    docker ps
4 查看宿主机上所有的容器（包括停止的）
    docker ps -a
5 停止容器
    docker stop 容器名字/id号
6 启动容器
    docker start 容器id/名字
  重启容器
    docker restart 容器id/名字  
    
7 容器的创建和启动（******）
    -创建：docker create --name=xxx redis
    docker create --name=test-container centos:centos7 ps -A
    -启动
    docker start test-container

    -容器一直运行的原因
        -它有一条前台进程,一直在运行
        -以后如果自己制作的镜像，运行起容器，必须有个可以夯住的命令
        -如果该命令结束，该容器也就结束了
        
    -创建并启动（run）
    -i：表示运行容器
    -t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。
    -d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）。
    --name :为创建的容器命名。如果不写，会自动分配一个名字（英文人名）
    -v：表示目录映射关系（前者是宿主机目录，后者是容器目录，映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。
    -p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
    docker run -it --name=myredis redis
        
 # 注意，docker run  镜像 如果本地没有，会先pull，再run

8 进入容器的几种方式（并不是真进入）
    第一种：docker exec -it  容器id（或者容器名字） /bin/bash   #新建一个终端执行命令
        docker exec 容器id ls 
        docker exec 容器id ps -aux
        exec真正的作用是在容器内执行命令
    第二种：ssh连接（容器内部装ssh服务端）
9 退出
    exit
    
10 文件拷贝
    -从宿主机拷贝到容器内部
        docker cp lqz.txt 容器id:/home
    -从容器内部拷贝到宿主机dic
        docker cp 容器id:/home/lqz.txt /app
11 目录挂载    (已经存在的容器就不支持，得新创建的时候挂载)
    docker run -di --name=mycentos99 -v /home/lqz:/home centos:centos7
    # 一旦挂载，以后宿主机目录内修改，同样影响容器内部
12 端口映射
    docker run -di -p 6377:6379 redis:latest
    
    # 了解：/usr/local/bin/docker-entrypoint.sh
    
13 查看容器详细信息
    docker inspect f81
    # 查看ip地址
    docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）


######################### 应用部署  #################
# 在容器内部署mysql
# -e表示环境变量
docker run -di --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
## 进入容器   env 可以看到
# 官方提供的
docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
        
# 在容器内部署redis
docker run -di --name=redis -p 6379:6379 redis:latest
        
# 在容器内部署nginx
docker run -di --name=nginx -p 80:80 nginx

# 纯净的centos7镜像--》容器---》装python3.6

######################### 部署应用映射外部目录  #################
# 部署redis，把配置文件和数据目录映射出来
# 操作步骤
    -1 mkdir /redis /redis/conf /redis/data
    -2 vim /redis/conf/redis.conf
        # 配置文件
        bind 0.0.0.0
        daemonize NO
        protected-mode no
        requirepass 123456
    -3 创建并运行容器
    docker run -p 6378:6379 --name redis_6379 -v /redis/conf/redis.conf:/etc/redis/redis.conf -v /redis/data:/data -di redis redis-server /etc/redis/redis.conf
    -4 本地window机器上远程连接到了docker里的redis
    -5 cmd窗口下
        redis-cli -h 10.0.0.100 -p 6378
    -6 认证
        auth 123456
    -7 写入数据
        set name lqz
    -8 保存数据
        save或者是bgsave
    -9 在宿主机的/redis/data路径下就能看到一个文件
    -10 不管多少次重启redis容器，数据都还在
    -11 原来的redis容器没了，按照第三步再启动一遍，数据都还在

######################### 迁移与备份  #################
######################### 其他操作  #################
# 删除所有容器（）
docker rm `docker ps -a -q`
# 删除所有镜像
docker rmi `docker images -q`

# 通过自己构建的image启动容器
docker run -id --name=mydjango -p 8088:8088  mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088
               
# 查看容器运行日志
docker logs 容器id
```

#### 1 容器做成镜像(项目在容器中)
```python
# 操作步骤
    1 启动一个python容器
        docker run -di --name=lqz python:3.6
    2 进入装软件
        docker exec -it lqz /bin/bash
        mkdir /project
        pip install django==1.11.11 -i https://pypi.douban.com/simple/
        退出
    3 把项目拷贝到容器内部
        docker cp /opt/lqz/django_test lqz:/project            
    4 把容器做成镜像
        docker commit lqz mydjango
    5 基于自己做的镜像运行容器
    docker run -id --name=mydjango -p 8088:8088  mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088
    docker run -id --name=mydjango2 -p 8089:8088  mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088
# 容器保存为镜像
    docker commit 容器名字 镜像名字
    docker commit 19b mydjango
# 把镜像打包成压缩包
    docker save -o mydjango.tar mydjango
# 把压缩包恢复为镜像
    docker load -i mydjango.tar    
```


#### 2 通过dockerfile构建出镜像(项目在宿主机中)
```python
######################### dockerfile  #################
1 dockerfile是什么
    一个文件，里面一堆指令，通过这个文件可以生成镜像
2 dockerfile指令
    命令                      作用
    FROM image_name:tag    定义了使用哪个基础镜像启动构建流程
    MAINTAINER user_name    声明镜像的创建者
    ENV key value    设置环境变量 (可以写多条)
    RUN command    是Dockerfile的核心部分(可以写多条)
    ADD source_dir/file dest_dir/file    将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
    COPY source_dir/file dest_dir/file    和ADD相似，但是如果有压缩文件并不能解压
    WORKDIR path_dir    设置工作目录
    
    
3 写一个dockerfile（文件名字必须交dockerfile）
## vim Dockerfile
FROM python:3.6
MAINTAINER lqz
EXPOSE 8080
ADD ./requirement.txt /home/
RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/
RUN pip install uwsgi -i https://pypi.douban.com/simple/
VOLUME ["/home"]
WORKDIR /home/django_test
CMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"]
#CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"] 

4 通过dockerfile构建出镜像
    docker build -t='django_1.11.11' .
5 查看镜像
    docker images 
    
6 启动容器
docker run -di --name=mydjango1 -v /opt/lqz/:/home -p 8080:8080 django_1.11.11

7 在外部访问即可 http://10.0.0.100:8080/

8 配置nginx转发
# 创建文件夹
mkdir -p /opt/nginx/conf /opt/nginx/html /opt/nginx/logs
# 新建配置文件
vim /opt/nginx/conf/nginx.conf
# 写入
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    upstream node    {
        server    10.0.0.100:8080;
        server    10.0.0.100:8081;
        server    10.0.0.100:8082;
    }
    server {
        listen       80;
        server_name  localhost;
        location / {
          #proxy_pass http://10.0.0.100:8080;
          #负载均衡配置
          proxy_pass http://node;
        }  
    }
}


# docker 中运行nginx
docker run --name mynginx -id -p 8888:80 -v /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /opt/nginx/html:/etc/nginx/html -v /opt/nginx/logs:/var/log/nginx nginx

# 访问http://10.0.0.100:8888/                

# 多启动几个docker容器
docker run -di --name=mydjango3 -v /opt/lqz/django_test2/:/home/django_test/ -p 8081:8080 django_1.11.11
docker run -di --name=mydjango2 -v /opt/lqz/django_test2/:/home/django_test/ -p 8082:8080 django_1.11.11
        
# 重启nginx
docker restart nginx
docker restart mydjango1

# 假设8081的容器挂了，8080的容器挂了，正常提供服务，
# 再把docker容器启动起来即可

```

#### 3 docker-compose
```python
######################### docker-compose  #################
1 docker-compose是一个单机情况下容器编排的工具
2 通过yml文件定义多个容器
3 默认名字docker-compose.yml
4 三个概念，Service  Networks ，Volumes
    一个service代表一个container，这个container可以从docker hub的image来创建，或者从本地dockerfile build的image来创建
5 version：有1，2，3版本，目前都用"3"


6 安装
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

7 验证安装成功
    docker-compose -v

################################ 部署 ########################################
# 1.vim Dockerfile
FROM python:3.6
MAINTAINER lqz
EXPOSE 8080
ADD ./requirement.txt /home/
RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/
RUN pip install uwsgi -i https://pypi.douban.com/simple/
VOLUME ["/home"]
WORKDIR /home/django_test
CMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"]

# 2.vim docker-compose.yml
version: "3"
services:
  nginx:
      image: nginx
      ports:
        - 80:80
      volumes:
        - /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
        - /opt/nginx/html:/etc/nginx/html
        - /opt/nginx/logs:/var/log/nginx
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:8080
    environment:
      REDIS_HOST: redis
    volumes:
      - /opt/lqz:/home
  web1:
    image: django_1.11.11
    ports:
      - 8081:8080
    volumes:
      - /opt/lqz:/home
  web2:
    image: django_1.11.11
    ports:
      - 8082:8080
    volumes:
      - /opt/lqz:/home

# 3.启动--运行
docker-compose up

########################################################################


########################Docker Compose File TOP配置参数概览########################
Docker Compose File 顶级配置项：

​ •version：指定Docker Compose File版本号

​ •services：定义多个服务并配置启动参数

​ •volumes：声明或创建在多个服务中共同使用的数据卷对象

​ •networks：定义在多个服务中共同使用的网络对象

​ •configs：声明将在本服务中要使用的一些配置文件

​ •secrets：声明将在本服务中要使用的一些秘钥、密码文件

​ •x-***：自定义配置。主要用于复用相同的配置。

# version：有1，2，3版本，目前都用"3"
# 一个service代表一个container，这个container可以从dockerhub的image来创建，或者从本地dockerfilebuild的image来创建
# service的启动类似docker run，可以指定network和volume，所有可以给servier指定network和volume



########################docker-compose命令########################
# 启动管理容器
docker-compose up  # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d  # 后台执行，一般我们看日志输出，不用这个

docker-compose stop  # 停止，不会删除容器和镜像
docker-compose down # 停止，并删除关联的容器
docker-compose start  # 启动yml文件管理的容器
docker-compose ps    # 正在运行的容器
docker-compose images # docker-compose管理的容器

docker-compose exec yml文件中写的service /bin/bash  # 进入到容器内
```

#### 私有仓库
```python
######################### 私有仓库 Harbor #################
1 把自己的镜像传到docker hub上
    -docker login  10.0.0.100/
    输入用户名
    输入密码
    -给你要上传的image打个标签docker tag 5452fa6715c0 10.0.0.100/liuqingzheng/django1.11.9:v1
    -docker images  10.0.0.100/liuqingzheng/
    -docker push 10.0.0.100/liuqingzheng/django1.11.9:v1
        
        
    -docker pull 10.0.0.100/liuqingzheng/django1.11.9:v1  

# 步骤
1 拉取私有仓库镜像
    docker pull registry
2 启动容器
    docker run -di --name=registry -p 5000:5000 registry
3 打开浏览器 输入地址http://10.0.0.100:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空


#####补充：docker WARNING: IPv4 forwarding is disabled. 解决方法
# 1.vim /etc/sysctl.conf 添加下面内容
net.ipv4.ip_forward=1
vm.overcommit_memory = 1
net.ipv6.conf.all.disable_ipv6=1
# 2.重启network和docker服务
systemctl restart network && systemctl restart docker


4 配置
    修改daemon.json
    vi /etc/docker/daemon.json
    添加以下内容，保存退出。
{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"],
"insecure-registries":["10.0.0.100:5000"]
}
  此步用于让 docker信任私有仓库地址
5 重启docker 服务
    systemctl restart docker
6 重启容器
    docker start registry
7 打标签
    docker tag 5452fa6715c0 10.0.0.100:5000/django1.11.11
8 上传到私有仓库
docker push 10.0.0.100:5000/django1.11.11
    
9 从私有仓库拉取镜像
docker pull 10.0.0.100:5000/django1.11.11    




######################### 官网部署多应用  #################
# 部署flask redis
1 创建Dockerfile
vim Dockerfile
FROM python:3.6
COPY . /app
WORKDIR /app
RUN pip install flask redis
EXPOSE 5000
CMD [ "python", "app.py" ]

2 创建docker-compose文件
vim docker-compose.yml
version: "3"
services:
  redis:
    image: redis
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis
3 创建app.py
vim app.py
from flask import Flask
from redis import Redis
import os
import socket
app = Flask(__name__)
redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
@app.route('/')
def hello():
    redis.incr('hits')
    return '你好! 查看 %s 次， hostname 是 %s.\n' % (redis.get('hits'),socket.gethostname())
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)
4 启动--运行
docker-compose up

######################## docker-compose.yml 如何写
version: '3'
services:
  wordpress:
    image: wordpress
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_PASSWORD: root
    volumes:
      - mysql-data:/var/lib/mysql
########################

######################### 多个容器直接通信方式  #################
1 端口映射到宿主机，直接访问宿主机
2 通过ip地址访问
3 run的时候指定 --link 容器 
docker run -di --name=centos1 centos:centos7
docker run -di --name=centos2 --link centos1 centos:centos7
    
进入到centos2中 ping centos1 可以ping同


# 跨主机的容器通信
    -端口映射


######################### nginx+django+mysql+redis 用docker-compose拉起三个容器 #################
# 基于本地的Volume：在容器创建或者run的时候，通过 -v指定
# 基于plugin的Volume：插件方式，第三方方案，如NAS，aws
# ## volume的类型
#1 受管理的data Volume，由docker后台自动创建（Data volume）
#2 绑定挂载的Volume，具体挂载可以由用户指定 （Bind Mouting）
#################Data volume
## 启动一个mysql的容器
docker run -d --name mysql1 -e MYSQL_ALLOW_EMPTY_PASSWORD=true mysql
docker volume ls 可以看到刚刚创建容器的voluem
docker volume id号 删除
docker inspect id号  可以看到mount到的本地某个位置
# 再创建，也会创建一个volume
# 删除容器，volume是不会被删除的(数据不会丢)

# 两个容器可以共用一个volume
docker run -d -v mysql:/var/lib/mysql --name mysql1 -e  MYSQL_ALLOW_EMPTY_PASSWORD=true mysql
docker run -d --name=mysql -v mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -p 3306:3306 mysql:5.7
docker run -di --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -v mysql:/var/lib/mysql mysql:5.7
# 进入到容器，创建一个数据库
# 停掉容器，删除容器
sudo docker volume ls    文件还在
# 重新一个容器，使用该volume
docker run -d -v mysql:/var/lib/mysql --name mysql2 -e  MYSQL_ALLOW_EMPTY_PASSWORD=true mysql
# 进入到容器，看到数据库还在
```


## 如何提高项目并发量
两个大点：减少交互，提高接口并发
前端：
1 移动端还是web端。静态资源，使用cdn
2 图片，短视频，放在第三方存储上
3 精灵图，好的小图片做成一个图，在前端通过定位
4 使用前端存储
5 前端缓存：响应头中有Cache-Control: max-age=xxx

后端部署：
6 使用nginx转发（不是直接使用uwsgi接受http请求，uwsgi协议）
7 使用性能高的wsgi服务器部署项目（uwsgi，gunicorn）
8 起多个uwsgi+django 服务，监听多个端口
9 nginx做负载均衡
10 多台机器起多个uwsgi+django 服务，nginx做负载均衡
11 动静分离，uwsgi只负责处理动态请求，静态请求直接用nginx去取，
12 静态资源（头像，图片），cdn，放到第三方云平台，oss，七牛云，公司自己搭建存储服务器（fastdfs，ceph）
13 页面静态化（首页，秒杀场景秒杀页面），数据同步问题，只要数据库变更了（管理员新增了一个轮播图），静态化的页面需要重新生成（celery使用场景）
13.1 单台nginx顶不住，高可用keepalive，nginx做集群，F5的硬件负载均衡器，dns负载均衡

代码层面：
14 使用异步，用多线程，用协程
15 使用异步任务框架celery，使用消息队列（rabbitmq），把任务做成异步
16 数据库查询语句的优化，sql索引的创建，尽量不要在for循环中执行sql，常慢sql，读写分离，集群，分库分表
17 使用缓存接口缓存，redis，主从，哨兵，集群 6台机器
18 个别接口全用缓存（qps高的接口）
19 搜索场景使用全文检索es，集群
20 代码逻辑层面
21 考虑换语言，写成一个个服务，一点点替换

文件管理:
创建/复制/移动/删除
查看文件内容(cat tac less more head tail tailf grep …)
联网下载文件(wget、curl)、文件上传与下载(rz、sz)
文件或命令查找(locate、which、whereis、find)
字符处理命令(sort、uniq、cut、sed、awk、wc、)
查看文件夹大小(方式1：ls -lh  方式2：du -h)

用户相关:
useradd,usermod,userdel,groupadd,groupmod,groupdel
su - username属于登陆式shell，su username属于非登陆式shell，区别在于加载的环境变量不一样。

权限管理: chmod 777 dir/
压缩打包: zip  unzip  tar
软件管理: rpm   yum      
磁盘管理: mount   


系统信息命令:
top:查看进程及资源占用情况
ps:查看进程信息
free:查看内存使用情况
df:查看磁盘占用情况
ifconfig:查看网络接口信息
netstat:查看网络状态信息
命令 --help


查看内存:free -m  
查看当前的进程状态(静态):ps aux |grep sshd
查看当前的进程状态(动态):top    q退出
杀死进程:kill -9 9160  kill命令杀死指定PID的进程   pkill nginx  通过服务名称杀掉进程
发现系统变慢时，通常做的第一件事，就是执行 top 或者 uptime 命令，来了解系统的负载情况
查看端口被占用的情况:lsof -i:8080
远程传输文件，在两台Linux上
scp  想要操作的文件地址  存放的目标文件地址
scp  test.txt root@192.168.0.109:/tmp/


[root@localhost ~]# ifconfig
[root@localhost ~]# which uwsgi
[root@localhost ~]# wget -c https://nginx.org/download/nginx-1.12.0.tar.gz
[root@localhost ~]# tar -zxvf nginx-1.12.0.tar.gz
[root@localhost ~]# netstat -tnlp | grep 80  查看80端口的信息
[root@localhost ~]# ps -ef|grep nginx
[root@localhost ~]# find /opt -name '*.py'  从/opt目录下查找所有的.py文件
[root@localhost ~]# man grep  查看grep的帮助手册
[root@localhost ~]# free -m 查看内存
[root@localhost ~]# iptables -L #查看防火墙规则


[root@localhost ~]# top
[root@localhost ~]# grep tom /etc/passwd  #查看用户信息，普通用户的id默认是从1000开始的
[root@localhost ~]# killall nginx
[root@localhost ~]# crontab -l  #查看Linux本机的定时任务
[root@localhost ~]# systemctl status network  #查看网络状态
[root@localhost ~]# cat /etc/os-release  查看发行版
[root@localhost ~]# tail -f a.txt 动态查看a.txt文件
[root@localhost ~]# wc -l /etc/passwd  看这个文件多少行
[root@localhost ~]# chmod 777 a.txt
[root@localhost ~]# history
```

.   代表当前的目录     
..  代表上一级的目录     #比如  cd ..  进入上一级目录 
~    代表当前登录用户的家目录，root用户就是/root   pyyu用户就是 /home/pyyu 
-    代表上一次的工作目录  
''    单引号中的内容，仅仅就是个字符串了，不识别任何其他的特殊符号
""     双引号中的内容，能够识别特殊符号，以及变量
>    #重定向输出覆盖符  ，如同 python的 with open 中的  w模式 
>>     #重定向输出 追加符  ，如同 a模式 

<    #重定向写入覆盖符，用的很少，用在数据导入等操作中,mysql数据导入 
<<   #用在cat命令中，很少见 


8080 ------自定义用的端口
3306--- mysql默认端口
80  --- http默认端口
443  ---https默认端口
6379 --- redis默认端口
22  -----  用于远程连接服务器用的端口 22


```python
##########常用命令
yum  provides  ifconfig    # 查看这个命令来自哪个包
whereis mysql              # 命令查看mysql是否安装,如果安装了mysql，就会显示文件安装的地址
ip addr                    # 查看网卡信息
ip addr show
uptime                     # 检查服务器运行了多久 ，3700 days 
mkdir  -p   /s25new/{男同学,女同学}  #创建一个/s25文件夹，且创建2个平级的文件夹
cat  -n  文件名  #读取内容，且显示行号


su - root                   #切换用户 
ifconfig
ssh  root@10.0.0.100
man  mkdir
mkdir  --help 
mkdir  /tmp/python{1..5}  
touch  /tmp/python_{a..d}  
which python                #输出命令所在的绝对路径        

rm -rf  /tmp/*  #删除/tmp下所有内容
rm -rf /tmp/    #删除tmp这个文件夹！！！

cp  -r  a   new_a
mv  旧文件名    新文件名
mv  你要移动的文件或是文件夹       移动之后的目录名(如果文件夹存在，则移动，不存在是改名)
mv  test.txt    b   #移动 test.txt文件  到 b文件夹下（b文件夹得存在，如果不存在就是重命名）
alias start="python3  /home/mysite/manager.py runserver  0.0.0.0:8000"

find   你要从哪找    -type 你要的文件类型是什么 -size  你要的文件内容多大  -name  你要的内容名字是什么
-type  f  是找普通文本文件 
-type  d  是找 文件夹 类型 

#在系统上 全局搜索，所有的.txt文件
find  /    -name  "*.txt"

#指定在etc目录下，进行局部搜索，一个网卡配置文件，网卡名字是以ifcfg开头的 ，文本类型文件
find   /etc   -type  f   -name   "ifcfg*"

#全局搜索，超过10M大小的 txt文本
[root@s25linux tmp]# find  /  -size +10M  -name "*.txt"

#生成大文件
echo  aa{1..50000}  > python.txt

#grep从文本中，过滤有用信息的命令   grep是支持正则表达式的
grep "你想过滤的字符串"   需要过滤的文件  #用法一
cat  文件   |   grep   "你想要的内容"   #用法二
[root@s25linux tmp]# cat /etc/passwd  |  grep  "pyyu"
pyyu:x:1000:1000:pyyu:/home/pyyu:/bin/bash 

#找出文件中含有 "大" 字的行，且显示此内容，在哪一行
grep -n "大"   test.txt   # -n 参数是显示行号

#忽略大小写，找出ALLOW_HOSTS=[]参数是否被修改
grep -i "al"  test.txt 

#过滤出此文件非空白行，如何操作？
拆解如下
找出所有的空白行 
[root@s25linux tmp]# grep "^$"   test.txt   #  "^$"  以空开头，以空结尾，因此是空白行
# -v 参数是 翻转过滤结果 ，找出 空白行以外的内容
[root@s25linux tmp]# grep -v   "^$"   test.txt

#过滤掉注释行，和空白行 ，如何操作？
[root@s25linux tmp]# grep -v  "^#"   test.txt | grep -v "^$"

#head和tail都是能够读取文件内容的
head  文件名  #默认从文件的前10行看
head  /etc/passwd  #默认看前10行
head -3  /etc/passwd  #查看文件的前3行

tail  文件名 #默认从文件的后10行看
tail -2  /etc/passwd   #查看文件的后2行

tail命令的 实时监控用法 ，可以用于检测线上的日志文件，检测用户的请求信息
tail -f  文件名  #实时刷新文件内容 
tail -f /tmp/test.txt  #能够检测文件内容的变化 

#scp命令  在2台linux机器(macos)之间，通过网络安全的传输文件，文件夹
案例1：
我登录的是 机器1：  192.168.178.134          机器2：192.168.178.235  

#需求1：将机器1的/tmp/好嗨哦.txt  发送到 机器2的/tmp目录下 
[root@s25linux tmp]# scp  /tmp/好嗨哦.txt root@192.168.178.235:/tmp/

#需求2：把机器2的/tmp目录下的资料 给拿到本地的/opt目录下
scp  你想要的内容   内容发送到哪里 
scp  root@192.168.178.235:/tmp/小样别偷看.txt     /opt/


#如果发送的是整个文件夹，就得加上 -r  递归的拷贝参数
[root@s25linux tmp]# scp  -r  ./lol    root@192.168.178.235:/tmp/

#用通配符发送多个文件
[root@s25linux tmp]# scp -r  ./*  root@192.168.178.235:/tmp/134bak/

#lrzsz工具  用于windows(基于xshell工具)和linux之间互相传递文件
1.安装此工具
yum install  lrzsz -y  

2.安装好lrzsz之后，就存在了2个命令   一个是 rz  一个是sz
rz  #直接输入rz命令，能够蹦出一个弹窗，接收windows的资料

sz  文件  #发送linux的一个文件，发给 windows某个位置，也是出现一个弹窗

#du命令
du 【参数】【文件或目录】
-s 显示总计
-h 以k，M,G为单位显示，可读性强

#统计/var/log/文件夹大小 
du -sh  /var/log/  

#显示当前目录下 所有文件的大小
[root@s25linux tmp]# du  -h ./*

#top命令能够显示 动态的进程信息  cpu、内存，网络，磁盘io等使用情况 ，也就是一个资源管理器, 按q退出

[root@bubu bubu]# top
top - 02:22:07 up 2 days, 12:57,  2 users,  load average: 0.25, 0.19, 0.13
Tasks: 121 total,   1 running, 120 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.3 us,  4.7 sy,  0.0 ni, 93.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :   995896 total,    99500 free,   421340 used,   475056 buff/cache
KiB Swap:  2097148 total,  2032892 free,    64256 used.   400992 avail Mem 

   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                                                                                                                 
 24910 root      20   0  187376  30712   5784 S  2.3  3.1   5:24.63 python                                                                                                                  
 24912 root      20   0  187376  30716   5784 S  2.3  3.1   5:26.47 python                                                                                                                  
 24911 root      20   0  113388  30348   5648 S  2.0  3.0   5:26.37 python                                                                                                                  
 26124 root      20   0  164196   2288   1588 R  0.3  0.2   0:00.11 top    


第一行 (uptime)
系统时间 主机运行时间 用户连接数(who) 系统1，5，15分钟的平均负载

第二行:进程信息
进程总数 正在运行的进程数 睡眠的进程数 停止的进程数 僵尸进程数

第三行:cpu信息
1.5 us：用户空间所占CPU百分比
0.9 sy：内核空间占用CPU百分比
0.0 ni：用户进程空间内改变过优先级的进程占用CPU百分比
97.5 id：空闲CPU百分比
0.2 wa：等待输入输出的CPU时间百分比
0.0 hi：硬件CPU中断占用百分比
0.0 si：软中断占用百分比
0.0 st：虚拟机占用百分比

第四行：内存信息（与第五行的信息类似与free命令）
total：物理内存总量
used：已使用的内存总量
free：空闲的内存总量（free+used=total）
buffers：用作内核缓存的内存量

第五行：swap信息
total：交换分区总量
used：已使用的交换分区总量
free：空闲交换区总量
cached Mem：缓冲的交换区总量，内存中的内容被换出到交换区，然后又被换入到内存，但是使用过的交换区没有被覆盖，交换区的这些内容已存在于内存中的交换区的大小，相应的内存再次被换出时可不必再对交换区写入。


#ps命令  用于查看linux进程信息的命令 
语法就是 
ps  -ef    # -ef，是一个组合参数，-e  -f 的缩写，默认显示linux所有的进程信息，以及pid，时间，进程名等信息 

#过滤系统有关vim的进程 
[root@s25linux ~]# ps -ef |  grep  "vim"
root      24277   7379  0 16:09 pts/1    00:00:00 vim ps是怎么用的.txt

#kill -9  pid

#netstat命令  查看linux的网络端口情况 
语法如下
常用的参数组合  -t -n -u -l -p    

[root@s25linux tmp]# netstat -tunlp   #显示机器所有的tcp、udp的所有端口连接情况

#例如验证服务器80端口是否存在
netstat  -tunlp  |  grep  80

#过滤3306端口是否存在 
netstat -tunlp |grep 3306


#过滤ssh服务是否正常
[root@s25linux tmp]# netstat -tunlp  |   grep   ssh
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1147/sshd
tcp6       0      0 :::22                   :::*                    LISTEN      1147/sshd


#有些公司为了保护服务器安全，更改了默认的远程连接端口
# ssh端口 26674    ip 是  123.206.16.61   账号是 xiaohu   密码是 xiaohu666

#我怎么登陆服务器呢？用如下的命令去连接服务器 
ssh  -p  26674    xiaohu@123.206.16.61  

ssh  -p 22 root@192.168.178.134
root@192.168.178.134's password:




####################################
##########常用文件
vim   /etc/sysconfig/network-scripts/ifcfg-ens33              #这是linux网卡配置文件
ONBOOT="yes"

systemctl stop NetworkManager  #关闭有线网服务
systemctl restart network  #重启有线网服务

# 环境变量只定位到软件目录下的bin
[root@s25linux tmp]# echo $PATH
/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin

vim  /etc/profile                                       #打开文件，在文件末尾，添加PATH值的修改
PATH="/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:"
export LC_ALL=zh_CN.UTF-8  #打开注释，系统支持中文
#export LC_ALL=en_US.UTF-8  #打开注释，系统就支持英文了



####vim命令的用法
在命令模式下，常用的指令 

$  快速移动到行尾
0  快速移动到光标的行首
x  删除光标所在的字符
g  移动到文件的第一行
G  移动到文件的最后一行 

/string    你要从文件开头寻找的内容，例如 /to   找出文件中所有的to字符，按下n键，跳转到下一个匹配的字符

?string     从文件的第行，向上搜索字符串信息   

%   找到括号的另一半 

yy   复制光标当前行 
3yy   复制光标后3行 
p    打印yy所复制的内容 
dd   删除光标所在行
4dd  删除光标向下的4行内容
dG   删除光标当前行，到行尾的所有内容
u  就是撤销上一次的动作 

如何快速的复制，打印生成多行内容 
例如 按下  9999yy  就是 复制  9999行，然后按下p打印，就能够快速的复制N多行了...


底线命令模式下
:wq!
:q!  不保存退出
:数字   快速的定位到某一行
:set nu   显示vim的行号 

#########################################

首先需要了解Mysql安装后的相关目录： 　 
1、数据库目录
　　/var/lib/mysql/
2、配置文件
　　/usr/share/mysql（mysql.server命令及配置文件）
3、相关命令
　　/usr/bin(mysqladmin mysqldump等命令)
4、启动脚本
　　/etc/rc.d/init.d/（启动脚本文件mysql的目录）
因此可通过如下方式查看：
1）查看安装目录，如上所示
2）查看服务是否启动：service mysql status
3）查看进程服务ps -aux | grep mysql
4）查看端口netstat -apn | grep 3306