linux12 -MYSQL数据库 --＞ 19数据库面试必备手册

数据库面试

1、基础

1、关系型和非关系型
# 关系型：
	mysql、oracle、db2、sqlserver
    mariadb
 # 1、数据之间彼此有关系或者约束
 # 2、存储数据的编写形式通常是以表格存储
 # 3、支持事物
 # 4、存储在硬盘中

# 非关系型：
	redis
	key.value
	memcache
	mongodb
# 1、存储的方式是k、v形式存储，不支持事务
# 2、是存储在内存（缓存）
# 字符编码
utf8mb4
注：oracle特别好，但是特别费钱，一般大公司才会用

2、四种语言的区别
#1、DDL语句    数据库定义语言： 数据库、表、视图、索引、存储过程，例如CREATE DROP ALTER
#2、DML语句    数据库操作语言： 插入数据INSERT、删除数据DELETE、更新数据UPDATE、查询数据SELECT
#3、DCL语句    数据库控制语言： 例如控制用户的访问权限GRANT、REVOKE（操作对象的权限）
# 4、DQL语句   数据查询语言：   select查询表中的数据
3、四种数据库
# information_schema： 
虚拟库，不占用磁盘空间，存储的是数据库启动后的一些参数，如用户表信息、列信息、权限信息、字符信息等
# performance_schema：
MySQL 5.5开始新增一个数据库：主要用于收集数据库服务器性能参数，记录处理查询请求时发生的各种事件、锁等现象 
# mysql：
授权库，主要存储系统用户的权限信息
# test：
MySQL数据库系统自动创建的测试数据库

4、数据库的增删改查
# 1、严格模式比较
针对不同版本会出现不同效果
5.6版本默认没有开启严格模式，规定只能存一个字符，你给多少字符，会自动截取
5.7之后的版本开启了严格模式，规定几个字符就是，字符多了会报错
Data too long for ..
#严格模式到底开不开呢
mysql5.7以后都是开启的；
使用数据库准则：
能尽量少让数据库干活就少干活，不要给数据库增加额外压力

# 2、日期比较
DATETIME的日期范围是1001——9999年（时间长，读写效率要慢）
TIMESTAMP的时间范围是1970——2038年（时间短，但是效率快） #选择这个就好

# 3、字符比较
#char类型：定长，简单粗暴，浪费空间，存取速度快
char的优缺点：存取速度比varchar更快，但是比varchar更占用空间

#varchar类型：变长，精准，节省空间，存取速度慢
varchar的优缺点：比char省空间。但是存取速度没有char快
# charvr和char那个更省空间
按道理来charvr更省空间，实际是分情况讨论的，
字符个数小于4个，charvr更省空间，如果10000条记录，差不多9000多小于4个字符，cahrvr却更省空间
字符个数正好4个，char却更省空间，如果10000条记录，差不多9000多正好等于4个字符，cahr却更省空间
# 枚举类型与集合类型
enum (单选 )只能在给定的范围内选一个值，如:性别 sex 男male/女female
set (多选) 在给定的范围内可以选择一个或一个以上的值（爱好1,爱好2,爱好3…) 
# 枚举类型与集合类型对比：
1、集合可以写一个，但是不能写没有列举的
2、枚举字段，后期存储数据的时候只能从枚举里面选择一个存储没有列举的

2、扩展

1、三种开发模式
#   程序员（开发人员）                          数据库管理者 DBA
    应用程序（调用存储过程）                       存储过程
    应用程序+sql语句                              管理好数据
    应用程序+orm框架                              管理好数据 # 用的最多
    
 # IO多路复用
https://blog.csdn.net/sehanlingfeng/article/details/78920423

# 第一种
应用程序：程序员写代码开发
mysql：提前编写好存储过程 ，供应用程序调用

优点：开发效率提升了，执行效率上去了
缺点：考虑到人为元素、跨不忙沟通的问题，后续存储过程的跨扩展性差

# 第二种
应用程序：程序员写代码开发之外，设计到数据库操作也自己手写

优点：存储过程的跨扩展性很高
缺点：编写sql语句太多频繁，后续还需要考虑sql优化的问题
# 第三种
应用程序：只写程序代码，不写sql语句，基于别人写好的mysql的python框架直接调用即可 
#框架 半成品  ORM跨架
优点： 开发效率比上面两种效率高
缺点：语句扩展性差，可能出现效率低下爱的问题
# 一般用第三种，出现效率问题在手动写sql
2、权限管理
#  1、mysql.user 
针对所有数据、所有库下所有表、以及表下的所有字段
#  2、msyql.db 
  只针对某一数据库下的所有表，以及表下的所有字段
#  3、tables_priv 
只针对某一张表、以及该表下的所有字段
#  4、columns_priv 
 只针对某一个字段
#一般给开发创建用户权限，建议不给delete权限
grant select,update,delete,insert on *.* to mm@'10.0.0.%'' identified by '123';
revoke all on *.* from tom@'%'; #撤销

3、重点

1、MySQL逻辑系统架构分为3层:
#  应用层（连接层）
#  MySQL服务层（SQL层）
#  存储引擎层   --> innodb
#  文件层（文件系统）
##### 1、连接层
1.验证用户的身份，用户名密码是否匹配
2.提供两种连接方式（TCP/IP连接、socket连接） # socket只能本地连接
3.连接层提供了一个与sql层交互的线程
##### 2、SQL层
1.接收连接层传来的SQL语句
2.验证语法
3.验证语义(DML,DDL,DCL,DQL) 检查你输入的SQL语句是 select insert update delete... grant
4.解析器:解析你的SQL语句,生成多种执行计划
5.优化器:接收解析器传来的多种执行计划,选择最优的一种
6.执行器:将优化器选择出的最优的SQL,执行
	6.1 建立一个与存储引擎层 交互的线程
	6.2 将执行语句交给存储引擎层,取数据 接收存储引擎层,结构化成表的数据结果
7.如果你的前端有缓存,写缓存（caches、buffers）
8.记录日志(binlog)  ---解析sql语句
##### 3、存储引擎层
1.接收到SQL层传来的SQL语句
2.与磁盘交互,取数据,结构化成表的形式,返回给SQL层
3.建立一个与SQL层交互的线程
# 存储引擎层就是硬件层

mysql数据管理软件服务端           --》 存储引擎innodb  #用户态内存空间
操作系统                        ---》 文件系统  # os cache
计算机硬件                      ---》 硬盘   #硬盘结构

2.什么是存储引擎
mysql的文件系统，主要是与磁盘交互
3、innodb与myisam的区别
1.myisam是表级锁，InnoDB是行级锁
2.myisam不支持事务，InnoDB支持事务
3.myisam不支持CSR，InnoDB支持CSR #故障自动恢复（CSR）

# 锁 当并发处理的数据的时候，只能一个成功，类似与抢票，只有一张票，多人同时抢，只能一个成功，锁是保证数据安全，但是会降低效率，所以要少用
表空间 ibd文件  ---存放的数据
3、存储引擎
mysql> show engines;  #查看搜索引擎

InnoDB存储引擎 
（必须有主键，如果没有  会自上而下找一个不为空且唯一的字段为主键），如果没有为自己添加一下隐藏的字段为主键，一般id为主键 # mysql5.5版本之后默认之后的存储引擎
MEMORY存储引擎  # 内存引擎（数据全部存储在内存），断电即丢失
BLACKHOLE存储引擎  # 黑洞，无论存什么都会丢失
MyISAM存储引擎  # 存储在内存，# mysql5.5版本之后默认之前的存储引擎，速度要比innodb更快，但是我们追求的是安全
InnoDB存储引擎（默认）：存在硬盘上
存储引擎（读取表）就是mysql中的一个小插件，表的类型，每一种存储引擎，就有自己独特的处理表的方式，存储数据更加安全

# 三大重要特性：
Supports transactions   #事务  要么全部执行成功，要么全部执行失败
row-level locking       # 锁机制 （行级锁）缺点，并发高  # 前两个是安全的
foreign keys            # 外键 （外键约束，数据和数据之间约束，防止脏数据出现）
级联删除，级联增加 

# mysiam存储引擎
		t1.frm：表结构
		t1.MYD：数据
		t1.MYI：索引
# innodb存储引擎
		t2.frm：表结构
		t2.ibd：表数据+索引 （表空间）
# mysql> create table t2(id int)engine=innodb;
# mysql> create table t2(id int)engine=myisam; 其他存储引擎类似

4、重中之重

1、 innodb存储引擎执行流程
# 1、执行阶段（1,2,3,4)
  - sql数据加载到内存，写undo log，更新内存中数据，写redo log buffer
#  2、事务提交阶段 (5,6,7)
  - redo log和binlog刷盘，commit标记写入redo log中
# 3、最后(8)
  - 后台io线程随机把内存中脏数据刷到磁盘上
具体是8个小步骤
1、执行一条update数据先从磁盘加载到buffer pool中，并进行数据加锁
2、先把源数据写到undo日志方便回滚
3、把buffer pool的数据更新后，得到脏数据 # 此时内存中的数据还是脏数据
4、把修改后的数据写到redo log buffer 中 
5. 准备提交事务redo log刷入磁盘  #redo log写的是修改后的数据 
6. 准备提交事务binlog写入磁盘 #binlog写的是执行的信息
7. 把binlog的文件名和位置写入commit（提交）标记，commit标记写入redolog中，事务才算提交成功；否则不会成功  #commit 提交
8. IO线程Buffer Pool中的脏数据刷入磁盘文件，完成最终修改
# 补充
脏数据:还没有写到硬盘的数据是脏数据
undo log  ==》 用于数据回滚
redo log  ==》 用于数据前滚

2、redo log 和binlog的刷盘策略
#  1、当提交事务的时候，redo log会根据自己刷盘规则 刷到磁盘上去
参数   innodb_flush_log_at_trx_commit  # 参数为1，事务提交成功，才刷到磁盘文件中
#  2、当提交事务的时候，binlog会根据自己刷盘规则 刷到磁盘上去
参数  sync_binlog  # 参数为1，事务提交成功，才刷到磁盘文件中

3、补充
7992行--->一页（16kB）

64个页--->一个区（1MB）

4个区---> 一个数据段（4M）  

叶子节点数据段+非叶子节点数据段+回滚数据段-》一个表空间
====================================================================================
# 多行内容ROW组成一个page
一个页又称为一个磁盘块block，是一次最小单位
一个页最多存放7992行记录，innodb存储引擎一个页的大小位为16k
多个页构成一个区extent
一个区是由64连续的页组成，每个页面16k，64个页面是1M
多个区构成一个段Segment
多个数据端构成一个表空间

4、独立和共享表空间
共享表空间：用户自主创建独立的表，每个表会有自己的独立的表空间
独立表空间：所有的数据和索引存放到一个文件中 ibdata1

# Msyql 5.5 不支持独立的表空间，不支持undo空间在线收缩功能
# Msyql 5.6 支持独立的表空间,不支持undo空间在线收缩功能
# Msql 5.7  支持独立的表空间,支持undo空间在线收缩功能
参数 innodb_max_undo_log_size = 11M 
5、简单说明在线迁移表
1、looktable使用库锁表
2、在新库中创建和主库相同的表名
3、蒋主库的表数据文件移到新库中  scp
4、在新库中移除表空间 rm ibd
5、导入新库

5、索引

1、什么是索引
1）索引就好比一本书的目录，它能让你更快的找到自己想要的内容。
2）让获取的数据更有目的性，从而提高数据库检索数据的性能。
# 索引是存储引擎中一种数据结构，或者说数据的组织方式，又称之为键key
  是存储引擎用于快速找到 记录的一种数据结构。
2、为何用索引
1、提升查询速度
2、降低了写效率
#  应用程序对数据的读写比例基本为10:1
3、创建索引的两个步骤
  create index xxx on user(id);
  1、提取索引字段的值当作key，value就是对应的本行记录
  10 -------------> 10 zs
  7 -------------->  7 ls
  2、以key的为基础比较大小，生成树型结构
  leaf node：叶子节点
  non-leaf node：根节点、树枝节点
 4、如何正确看待索引
 1、项目上线前就提前考虑
 2、以什么字段的值为基础构建索引
 3、最好是不为空、唯一、占用空间小的字段
 4、索引不是越多越好，对于不必要的字段加索引，反而加大io负担
# 1、当表中有大量数据存在的前提下，创建索引速度会很慢
# 2、在创建索引完毕之后，对表读的性能会大幅度提升，但是会写的性能会很慢
    # 注：
1、索引不要随意创建
2、如果上线之后载想着加索引，光定位到索引身上就需要耗费很多时间，排查成本很高
3、如果某一张表的ibd文件中创建了很多棵索引树，意味着很小的一个update语句，就会导致很多棵索引树需要发生变化，从而把硬盘IO打上去
# 一个磁盘块存储的限制的
为什么用id字段为索引
占用空间少，一个磁盘块能够存储的数据多
那么降低了树的高度，从而减少查询次数

# 索引的根本原理就是把硬盘IO次数降下来

5、索引到底是一种什么样的数据结构
# 1、索引到底是一种什么样的数据结构：B+树
  二叉树、平衡二叉树、B树=》B+树
  
#二叉树：
  左节点的key值小于当前节点的key，而右节点的key大于当前节点，但是不能提速  -- #三次查找
  create index idx_id on use(id);
  select * from user where id =100;
  
 # 平衡二叉树：
    左子树与右子树的高度差不超过1
 # 一次iO就读一次节点，就相当于一辆卡车，只拉一个快递(一个节点只读一个一页到内存)
    每个节点只放了一条数据，相当于innodb存储引擎共16k的数据只放了一条数据，几个字节，浪费了许多

 # B树：
      一次io读入内存是一页数据，或者叫一个磁盘块的数据，磁盘块里包含了n个节点
      ps：根节点页常驻内存 -- #两次查找
 问题：页中的节点既存放key又存放对应记录值（values --》对应的是一行的完整记录）
		
# B+树：
    1、非叶子节点只放key（根、树枝节点放key），只有叶子节点才放key：value  --》非叶子节点能存放的key个数变多，衍生出指针越多，树会变得更矮更胖
    2、叶子节点也指针指向，是有序排列的，这意味着B+树在排序操作上有天然的优势（范围查询速度快）# （因为提前排好了，再次查找的时候不需要从头再找）--》叶子节点是双向连接的  
    select * from user where id > 18;
     先找到id=19所在的叶子节点，然后只需要根据叶子节点的链表指向向右查找下一个节点（id =19、id=20...）即不需要在回根节点查找
    3、叶子节点内的key值是单向链表，叶子节点和叶子节点之间是双向链表。即全都排好序了  --》排序会很快   
    4、一个页、一个磁盘块、一个节点固定大小16k，可以存放的数据量就很多
      安装每个节点存放1000数据来算，三层的B+树可以组织多少条数据1000  *1000 * 1000
    
    # 特点：
       1、B树只擅长等值查询
       2、B+树擅长等值查询、范围查询
       
# 总结：
只要叶子节点才是存放的数据是真实的，其他数据都是虚拟数据的
树的层级越高，所经历的步骤就越多（树越高，查询的层级就越多）
树越低越好，查询速度越快
# 如果存1000个数据，那么三层B+树可以存放上10亿条数据 --------》 树的高度是几，那个n就是几 n的三次方		

• B+树和B树的不同

1> B+树非叶子节点non-leaf node上是不存储数据的，仅存储键，而B树的非叶子节点中不仅存储键，也会存储数据。B+树之所以这么做的意义在于：树一个节点就是一个页，而数据库中页的大小是固定的，innodb存储引擎默认一页为16KB，所以在页大小固定的前提下，能往一个页中放入更多的节点，相应的树的阶数（节点的子节点树）就会更大，那么树的高度必然更矮更胖，如此一来我们查找数据进行磁盘的IO次数有会再次减少，数据查询的效率也会更快。


2> B+树的阶数是等于键的数量的，例如上图，我们的B+树中每个节点可以存储3个键，3层B+树存可以存储 3*3*3 =9个数据。所以如果我们的B+树一个节点可以存储1000个键值，那么3层B+树可以存储1000×1000×1000=10亿个数据。而一般根节点是常驻内存的，所以一般我们查找10亿数据，只需要2次磁盘IO，真是屌炸天的设计。


3> 因为B+树索引的所有数据均存储在叶子节点leaf node，而且数据是按照顺序排列的。那么B+树使得范围查找，排序查找，分组查找以及去重查找变得异常简单。而B树因为数据分散在各个节点，要实现这一点是很不容易的。而且B+树中各个页之间也是通过双向链表连接的，叶子节点中的数据是通过单向链表连接的。其实上面的B树我们也可以对各个节点加上链表。其实这些不是它们之前的区别，是因为在mysql的innodb存储引擎中，索引就是这样存储的。也就是说上图中的B+树索引就是innodb中B+树索引真正的实现方式，准确的说应该是聚集索引（聚集索引和非聚集索引下面会讲到）


ps :通过上图可以看到，在innodb中，我们通过数据页之间通过双向链表连接以及叶子节点中数据之间通过单向链表连接的方式可以找到表中所有的数据
    #注意：MyISAM中的B+树索引实现与innodb中的略有不同。在MyISAM中，B+树索引的叶子节点并不存储数据，而是存储数据的文件地址

# 1、innodb存储引擎索引分类：
   1、hash索引：更适合等值查询，不适合范围查询  # innodb存储引擎不支持hash索引
   2、B+树索引：等值查询与范围查询都快
   3、全文索引：只可以用在MyISAM引擎  
   
6、什么是聚集索引，什么是辅助索引
 # 1、(主键索引)、聚集索引、聚簇索引：
   以主键字段的值作为key创建的索引（B+树）
   一张表中有且只有一个,通常应该是id字段，该B+树的叶子节点放的是主键值和本行完整的记录
   即： 表中的数据都聚集在叶子节点，所以称为聚集索引
   select * from user where id=2;
 # 2、（非聚集索引）、（非聚簇索引）、（二级索引）辅助索引：
   非聚集索引，非聚簇索引，辅助索引、二级索引:以非主键字段值为key构建的B+树，该B+树的叶子节点存放的是key与其对应的主键字段值 
   create index yyy on user(name);
   select * from user where name="xxx";
   
ps：一张innodb存储引擎表中必须要有且只能由一个聚集索引，但是可以多个辅助索引
    针对非主键字段创建的索引（一张表中可以有多个）
# 3、聚集索引与辅助索引的异同
  相同点：
    都是B+树结构，意味着非叶子节点只放key
    而叶子节点放key：value

  不同之处
    聚集索引叶子节点key对应的那个value值是一整行完整的记录
    辅助索引叶子节点key对应的那个value值是其所对应的主键字段值
    
# 优化：
 尽量避免回表操作，主键索引最后在前面，辅助索引在右面

7、什么是覆盖了索引，什么是回表操作，如何优化sql做到覆盖索引
# 1、覆盖索引和回表操作									
覆盖索引：在当前你命中的索引结构中就能能到你想要的所有数据，称之为覆盖了索引
    主键索引-》id字段
    辅助索引-》name字段
select * from t3 where id = 3;             -- 覆盖了索引
select name,id from t3 where name="egon";  -- 覆盖了索引
		
回表操作/查询：在当前你命中的索引结构中不能拿到你想要的所有数据，那么需要根据其对应的主建字段去聚集索引里重新查一遍，直到拿到完整记录，称之为回表操作
    主键索引-》id字段
    辅助索引-》name字段
select name,id,age from t3 where name="egon";

8、什么是联合索引，联合索引的key是什么，什么是最左前缀匹配原则，何时应该建立联合索引
# 1、联合索引->最左前缀匹配原则
    -primary key(id,name):联合主键索引
    -unique(id,name):联合唯一索引
    -index(id,name):联合普通索引
    
    create index idx_xxx on s1(name,age,gender);
    查询条件中出现：name、age
    查询条件中出现：name、gender
    查询条件中出现：name、age、gender

    where  age = 18 and name = "egon"  and gender="male"
    10,11,12
    10,13,0
======================================================================================
# 数据库索引

1、对区分度高并且占用空间小的字段建立索引
2、针对范围查询命中了索引，如果范围很大，查询效率依然很低，如何解决
	1、要么把范围缩小
	2、要么就分段/分页取值，一段一段取最终把大范围给取完
	3、缓存
	
3、索引下推技术（默认开启）# 就是好多种方案选择最优的那种查找出来的
4、不要把查询字段放到函数或者参与运算
	select count(*) from where id*12 = 3;
	select count(*) from where id = 3/12;
5、索引覆盖
	在命中索引的前提下，select查找值存在于本索引树中
	create index idx_name on s1(name);
	select name,id from s1 where name="egon";  -- 覆盖了索引
	select name,id,age from s1 where name="egon";  -- 没有覆盖索引，需要回表操作
	
注意：如果查询条件是用的主键字段，那么无法select查什么都会覆盖索引，都不需要回表,所以说，在查询语句中，能用主键字段作为查询依据就尽量用它

单表300w条记录-》硬盘空间200m

uv：user view单日累计用户访问---》反映的是网站的规模
2-5w
pv：page view单日累计页面被点击的次数---》反映的是产品的好坏
20w-50w

最大并发（同时在线人数最大多少）：一天内，某一时刻的并发量
1000人同时在线

数据库（读多写少）：

累计2w的UV，平均每人往数据库中写入一条数据，
那么单日新增数据条数为2w条
2w条数据库-》占用空间大概2M

结论：以2-5w uv为例，单日数据库空间增长量从几M到几十M不等

#  建立完索引，那个数据的ibd文件是变大了，但是如果删除完索引，但是那个ibd文件却不会变小，这是一个bug
#  因为ibd里面的数据和索引里面的内容都放在ibd文件里了
8、针对全表查询语句如何优化？

应用场景：用户想要浏览所有的商品信息
select count(id) from s1;

# 1、如何优化：
开发层面分页查找，用户每次看现从数据中拿

# 2、针对等值查询
以重复度低字段为基础创建索引加速效果明显
create index xxx on s1(id);
select count(id) from s1 where id = 33;

以重复度高字段为基础创建索引加速效果明显
# 总结：给重复低、且占用空间小的字段值为基础构建索引

# 3、关于范围查询
select count(id) from s1 where id=33;
select count(id) from s1 where id>33;
select count(id) from s1 where id>33 and id < 36;
select count(id) from s1 where id>33 and id < 1000000;
# 总结：innodb存储能加速范围查询，但是查询范围不能特别大
# 4、关于条件字段参与运算
select count(id) from s1 where id*12 = 10000;
select count(id) from s1 where id = 10000/12;
select count(id) from s1 where func(id) = 10000/12;

# 总结：不要让条件字段参与运算，或者说传递给函数

6、事务

1、什么是事务
# 什么是事务
顾名思义就是要做的事情，事务就相当于一个盛放sql的容器
事务中的sql要么全部执行成功，要么所有已经修改的操作都回滚到原来的状态，即一条sql也别想成功

# 作用
保证了数据操作的安全性，一致性
2、如何使用事务
# 事务相关的关键字

# 1、开启事务
start transaction == behgin
# 2、回滚（回到事务执行之前的状态）
rollback
# 3、确认（确认之后就无法回滚了）
commit
# 总结：
当你想让sql语句同时保证数据的一致性，要么同时成功，要么同时失败，那么就可以考虑使用事务
3、事务四大特性
ACID 四大特性 #ACID
# A: 原子性 (Atomic)
一个事务是一个不可分割的单位，事务中包含的诸多操作，要么同时失败，要么同时成功
所有sql语句作为一个单元全部成功执行或全部取消。
# C:一致性 （Consistent）
事务必须是是数据库一致性的状态变成另外一个一致性的状态，一致性根原子性密切相关的,
如果数据库在事务开始时处于一致状态，则在执行该事务期间将保留一致状态。
# I：隔离性 (Isolated)
一个事务的执行不能被其他事务干扰,事务之间不相互影响。
# D：持久性 (Durable)
也可以称为永久性，一个事务一旦提交成功执行成功，那么它就是对数据库中的数据修改是永久的
4、事务的三种模式
1、自动提交事务（隐式开启、隐式提交） # 默认
2、隐式事务\\（隐式开启、显式提交）
2、隐式事务\\（隐式开启、显式提交） #开发
# 注意，重要的事说三遍
这种方式在当你使用commit或者rollback后，事务就结束了
再次进入事务状态需要再次start transaction
4、事务的保存点
1、设置保存点savepoint 保存点名字
2、回滚到某个保存点，该保存点之后的操作无效，rollback 某个保存点名
3、取消全部事务，删除所有保存点rollback
# 注意：rollback和commit都会结束掉事务，这之后无法再回退到某个保存点
5、数据库读现象
# 读现象  --》 在并发场景下，并发的多个事务操作同一份数据，而产生的一些奇怪的独现象

# 1.脏读  --》原因  -- 设置安全级别低导致的
Dirty Reads，比如有两个事务并行执行操作同一条数据库记录，A事务能读取到B事务未提交的数据。
# 2.不可重复读
Non-Repeatable Reads，同样是两个事务在操作同一数据，如果在事务开始时读了某数据，这时候另一个事务修改了这条数据，等事务再去读这条数据的时候发现已经变了，这就是没办法重复读一条数据。
# 3.幻读
Phantom Read，与上方场景相同，事务一开始按某个查询条件没查出任何数据，结果因为另一个事务的影响，再去查时却查到了数据，这种就像产生幻觉了一样，被称作幻读。
# 总结
`脏读
指事务A读取到事务B修改但未提交事务的数据。
(事务B未执行commit的时候，但是事务A却读取到了)，硬盘的数据和读取的数据不一样
`不可重复读
每次读取的数据不一样，读一次数据，数据每次不一样）

7、锁

1、什么是锁
	顾名思义就是锁定的意思，修改数据时锁住数据，锁是一种保障数据的机制，如何保障?
2、为什么用锁？
    以互斥锁为例,让多个并发的任务同一时间只有一个运行（注意这不是串行），牺牲了效率但换来数据安全
    在事务ACID特性过程中，“锁”和“隔离级别”一起来实现“I”隔离性的作用，并发写同一份数据的时候安全，保证数据安全
3、锁的优缺点
    优点：保障并发场景下的数据安全
    缺点：降低了效率
# 所以我们在使用锁时尽可能缩小锁的范围，即锁住的数据越少越好，并发能力越高
4、锁的分类
# 1、按锁的粒度划分，可分为行级锁、表级锁、页级锁。（mysql支持）
# 2、按锁级别划分，可分为共享锁、排他锁
# 3、按使用方式划分，可分为乐观锁、悲观锁
# 4、按加锁方式划分，可分为自动锁、显式锁
# 5、按操作划分，可分为DML锁、DDL锁
5、行级锁
# 行级锁  -->支持引擎：InnoDB
行级锁是Mysql中锁定粒度最细的一种锁，表示只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。其加锁粒度最小，但加锁的开销也最大。

行级锁分为共享锁 和 排他锁。
# 特点：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低，并发度也最高。
行级锁定分为行共享读锁（共享锁）与行独占写锁（排他锁） 
# 共享锁（S）：SELECT  FROM table_name WHERE ... LOCK IN SHARE MODE
# 排他锁（X)：SELECT  FROM table_name WHERE ... FOR UPDATE 
# 排它锁======== 等于========互斥锁
6、锁的使用
事务一对id=3的行加了互斥锁之后，其它事务对id=3行不能加任何锁（写不行，但是可以读）
事务一对id=3的行加了共享锁之后，其它事务对id=3行只能加共享锁，或者不加锁（写不行，但可以读）
排他锁：保证在多事务操作时，数据的一致性。(在我修改数据时，其他人不得修改) # X 排查锁 一般用于写数据
共享锁：保证在多事务工作期间，数据查询时不会被阻塞。 # S 共享锁 一般用于读数据
7、多版本并发控制（MVCC）
乐观锁：多事务操作时，数据可以被同时修改，谁先提交，谁修改成功。
悲观锁：多事务操作时，数据只有一个人可以修改。
# 1）只阻塞修改类操作（排它锁），不阻塞查询类操作（共享锁）
# 2）乐观锁的机制（谁先提交谁为准）
# 在MVCC并发控制中，读操作可以分成两类：
  快照读 (snapshot read)与当前读 (current read)。
# 1、乐观锁并未真正加锁，效率高。一旦锁的粒度掌握不好，更新失败的概率就会比较高，容易发生业务失败。
# 2、悲观锁依赖数据库锁，效率低。更新失败的概率比较低。
8、事务隔离级别
1.RC: read committed  允许事务查看其他事务所进行的已提交更改 #读未提交
2.RU: read uncommitted（独立提交），未提交读，允许事务查看其他事务所进行的未提交更改； #读提交
3.RR: repeatable read  可重复读 InnoDB 的默认级别	#commit提交以后可能看不到数据变化，必须重新连接
4.serializable：串行化:，将一个事务的结果与其他事务完全隔离  #如果一个事务没有提交，查询也不能查了
	# 我改微信头像时你不能看我的信息，我看你朋友圈的时候你不能发朋友圈、不能看朋友圈
9、 innodb存储引擎的锁机制
# 1、命中索引则通过索引锁定行，简称为锁索引
命中中的是聚集索引，就通过聚集索引本身来锁定行即可
id为主键
select * from t1 where id = 3;

命中中的是辅助索引，会先锁定辅助索引，然后再对应聚集索引中的节点
name为辅助索引
select * from t1 where name="egon";  -- "egon":10

# 2、如果没有命中索引，会把所有的行都锁住，相当于表锁
 强调：命中了索引才会锁行，不是说有索引就锁行
 强调：条件中引用的索引字段，也不一定会命中
 10、行级锁三种算法
 InnoDB有三种行锁的算法，都属于排他锁：
# 1、Record Lock：单个行记录上的锁。
# 2、Gap Lock：间隙锁，锁定一个范围，但不包括记录本身。GAP锁的目的，是为了防止同一事务的两次当前读，出现幻读的情况。
当我们用范围条件而不是相等条件检索数据，并请求共享或排他锁时，InnoDB会给符合条件的已有数据记录的索引项加锁；
对于键值在条件范围内但并不存在的记录，叫做“间隙（GAP)”，InnoDB也会对这个“间隙”加锁，这种锁机制就是所谓的间隙锁（Next-Key锁）。 
# 例如
例：假如employee表中只有101条记录，其depid的值分别是 1,2,...,100,101，下面的SQL：
mysql> select * from emp where depid > 100 for update;是一个范围条件的检索，并且命中了索引，InnoDB不仅会对符合条件的empid值为101的记录加锁，也会对empid大于101（这些记录并不存在）的“间隙”加锁。
复制代码
# 3、Next-Key Lock：等于Record Lock结合Gap Lock，也就说Next-Key Lock既锁定记录本身也锁定一个范围，特别需要注意的是，InnoDB存储引擎还会对辅助索引下一个键值加上gap lock。
对于行查询，innodb采用的都是Next-Key Lock，主要目的是解决幻读的问题，以满足相关隔离级别以及恢复和复制的需要。

11、行锁优化建议
# 1、尽可能让所有数据检索都通过索引来完成， 从而避免无索引行锁升级为表锁
# 2、合理设计索引，尽量缩小锁的范围
# 3、尽可能减少检索条件，避免间隙锁
# 4、尽量控制事务大小，减少锁定资源量和时间长度
# 5、尽可能低级别事务隔离

8、面试手册

1、你接触过哪几种数据库软件，各自的优缺点是什么？

2、MySQL数据库的几种日志格式有什么区别？

3、MySQL的存储引擎有哪几种？

4、MySQL主从复制原理是什么？

5、MySQL中myisam和innodb的区别？

6、字段类型varchar和char的区别是什么？varchar(50)中50代表什么？

7、关系型数据库和非关系型数据库的区别？你都用过哪些？

8、MySQL数据库备份有哪几种备份方式？如何选择？

9、之前公司的数据备份采用什么样的备份方案？如何实施？

10、实际使用中使用过哪几种数据恢复方式？

11、什么是数据库事务？

12、数据库事务的特性是什么？

13、数据库的部署环境以及部署方式？

14、如果单表数据量过大，有什么优化方式？

15、针对数据库权限，你们是如何管理的?

16、详细描述SQL语句分类及对应代表性关键字。

17、MySQL有哪些日志，分别是什么用处？

18、MySQL服务器因断电、异常关闭等导致表损坏，无法读取表数据的时候，如何进行修复？

19、MySQL数据库中出现中文乱码是什么原因？如何解决？

20、事务的隔离级别？

21、MySQL主从环境部署流程的重点是什么？

22、nosql指什么？

23、用过什么监控软件？

24、常用的监控软件有哪些特点？

25、为什么要使用监控软件？最终要达到的目的是什么？

26、zabbix有哪些优势？

27、使用zabbix主要监控哪些内容？

28、zabbix架构体系有哪些？

9、参考答案

# 1、关系型数据库-MySQL
在不同的引擎上有不同的存储方式。
查询语句是使用传统的sql语句，拥有较为成熟的体系，成熟度很高。
开源数据库的份额在不断增加，mysql的份额也在持续增长。
缺点就是在海量数据处理的时候效率会显著变慢。
  
非关系型数据库MongoDB
优势：
 1、在适量级的内存的MongoDB的性能是非常迅速的，它将热数据存储在物理内存中，使得热数据的读写变得十分快。
 2、MongoDB的高可用和集群架构拥有十分高的扩展性。
 3、在副本集中，当主库遇到问题，无法继续提供服务的时候，副本集将选举一个新的主库继续提供服务。
 4、MongoDB的Bson和JSon格式的数据十分适合文档格式的存储与查询。

劣势：
 1、 不支持事务操作。MongoDB本身没有自带事务机制，若需要在MongoDB中实现事务机制，需通过一个额外的表，从逻辑上自行实现事务。
 2、 应用经验少，由于NoSQL兴起时间短，应用经验相比关系型数据库较少。
 3、MongoDB占用空间过大。
 
 非关系型数据库Redis
Redis是NOSQL,即非关系型数据库,也是缓存数据库,即将数据存储在缓存中,缓存的读取速度快,能够大大的提高运行效率,但是保存时间有限。
redis用于存储使用较为频繁的数据到缓存中，读取速度快。
MySQL偏向于存数据,Redis偏向于快速取数据,但Redis查询复杂的表关系时不如MySQL,所以可以把热门的数据放Redis,MySQL存基本数据。

# 2、mysql binlog 三种格式
mysql的binlog日志作用是用来记录mysql内部增删改等对mysql数据库有更新内容的记录（对数据库进行改动的操作），对数据库查询的语句如show，select开头的语句，不会被binlog日志记录，最大的作用是用来数据增量恢复和主从库复制

ROW
ROW格式会记录每行记录修改的记录，这样可能会产生大量的日志内容,比如一条update语句修改了100条记录，那么这100条记录的修改都会被记录在binlog日志中，这样造成binlog日志量会很大，这种日志格式会占用大量的系统资源，mysql5.7和myslq8.0安装后默认就是这种格式。

STATEMENT
记录每一条修改数据的SQL语句（批量修改时，记录的不是单条SQL语句，而是批量修改的SQL语句事件）所以大大减少了binlog日志量，节约磁盘IO，提高性能,看上面的图解可以很好的理解row和statement 两种模式的区别。
但是STATEMENT对一些特殊功能的复制效果不是很好，比如：函数、存储过程的复制。由于row是基于每一行的变化来记录的，所以不会出现类似问题

MIXED
实际上就是前两种模式的结合。在Mixed模式下，MySQL会根据执行的每一条具体的sql语句来区分对待记录的日志形式，也就是在Statement和Row之间选择一种。

# 3、MyISAM

使用这个存储引擎，每个MyISAM在磁盘上存储成三个文件。

（1）frm文件： 存储表的定义数据
（2）MYD文件：存放表具体记录的数据
（3）MYI文件：存储索引

INNODB
InnoDB是默认的数据库存储引擎，他的主要特点有：

（1）可以通过自动增长列，方法是auto_increment。

（2）支持事务。默认的事务隔离级别为可重复度，通过MVCC（并发版本控制）来实现的。

（3）使用的锁粒度为行级锁，可以支持更高的并发；

（4）支持外键约束；外键约束其实降低了表的查询速度，但是增加了表之间的耦合度。

（5）配合一些热备工具可以支持在线热备份；

（6）在InnoDB中存在着缓冲管理，通过缓冲池，将索引和数据全部缓存起来，加快查询的速度；

Memory
将数据存在内存，为了提高数据的访问速度，每一个表实际上和一个磁盘文件关联。
（1）支持的数据类型有限制，比如：不支持TEXT和BLOB类型，对于字符串类型的数据，只支持固定长度的行，VARCHAR会被自动存储为CHAR类型；

（2）支持的锁粒度为表级锁。所以，在访问量比较大时，表级锁会成为MEMORY存储引擎的瓶颈；

（3）由于数据是存放在内存中，一旦服务器出现故障，数据都会丢失；

（4）查询的时候，如果有用到临时表，而且临时表中有BLOB，TEXT类型的字段，那么这个临时表就会转化为MyISAM类型的表，性能会急剧降低；

# 4、当复制开始时，从库就会创建从库I/O线程和从库的SQL线程进行复制处理。

从库I/O线程：当START SLAVE语句在从库开始执行之后，从库创建一个I/O线程，该线程连接到主库并请求主库发送binlog里面的更新记录到从库上。 从库I/O线程读取主库的binlog输出线程发送的更新并拷贝这些更新到本地文件，其中包括relay log文件。

从库的SQL线程：从库创建一个SQL线程，这个线程读取从库I/O线程写到relay log的更新事件并执行。

# 5、
1>.InnoDB支持事物，而MyISAM不支持事物
2>.InnoDB支持行级锁，而MyISAM支持表级锁
3>.InnoDB支持MVCC, 而MyISAM不支持
4>.InnoDB支持外键，而MyISAM不支持
5>.InnoDB不支持全文索引，而MyISAM支持。

# 6、char是一种固定长度的类型，varchar则是一种可变长度的类型，它们的区别是：
char(M)类型的数据列里，每个值都占用M个字节，如果某个长度小于M，MySQL就会在它的右边用空格字符补足。在varchar(M)类型的数据列里，每个值只占用刚好够用的字节再加上一个用来记录其长度的字节。
varchar(50)表示最多占用50个字符。

# 7、关系型数据库最典型的数据结构是表，由二维表及其之间的联系所组成的一个数据组织
优点：
1、易于维护：都是使用表结构，格式一致；
2、使用方便：SQL语言通用，可用于复杂查询；
3、复杂操作：支持SQL，可用于一个表以及多个表之间非常复杂的查询。
缺点：
1、读写性能比较差，尤其是海量数据的高效率读写；
2、固定的表结构，灵活度稍欠；
3、高并发读写需求，传统关系型数据库来说，硬盘I/O是一个很大的瓶颈。
常用的关系型数据库有Oracle、mysql、sqlserver、postgresql

非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方法的集合，可以是文档或者键值对等。
优点：
1、格式灵活：存储数据的格式可以是key,value形式、文档形式、图片形式等等，文档形式、图片形式等等，使用灵活，应用场景广泛，而关系型数据库则只支持基础类型。
2、速度快：nosql可以使用硬盘或者随机存储器作为载体，而关系型数据库只能使用硬盘；
3、高扩展性；
4、成本低：nosql数据库部署简单，基本都是开源软件。
非关系型数据库常见的软件有Redis、mongdb

# 8、在之前工作中，经常用到的两种备份方式是mysqldump以及xtrabackup
mysqldump是逻辑备份，备份效率较低，数据量较少的情况下可以采用mysqldump的备份方式
xtrabackup是物理备份，备份效率高，切支持在线热备，缺点是只支持innodb引擎。数据量较大的情况下可使用xtrabackup的方式进行备份。

# 9、之前工作中公司业务量较少，且生产环境是阿里云的RDS，因此采用阿里云RDS的备份策略以及本地备份结合的方式。
备份策略是每天凌晨两点进行一次全量备份，本地备份则是通过脚本以及计划任务，同样是每天进行一次全备，并且每天的备份数据进行打包压缩，并保存三个月。

# 10、实际工作中主库的宕机故障没有发生过，但是有一些临时需求，开发环境需要导入生产环境的数据进行调试，使用全量结合增量恢复的方式，将备份的全量数据以及增量数据通过xtrabackup恢复到数据库中。

# 11、事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元)
一个完整的业务需要批量的DML(insert、update、delete)语句共同联合完成
事务只和DML语句有关，或者说DML语句才有事务。这个和业务逻辑有关，业务逻辑不同，DML语句的个数不同

# 12、事务四大特征(ACID)
原子性(A)：事务是最小单位，不可再分
一致性(C)：事务要求所有的DML语句操作的时候，必须保证同时成功或者同时失败
隔离性(I)：事务A和事务B之间具有隔离性
持久性(D)：是事务的保证，事务终结的标志(内存的数据持久到硬盘文件中)

# 13、之前工作中生产环境的数据库都是采用阿里云的RDS服务，采用的是阿里云企业版的RDS产品。
开发环境是在本地服务器部署的，基于linux操作系统部署的。
部署过程中采用的是源码编译安装的方式。
# 14、
1）优化索引
2）进行表的切割。根据实际表的字段采用水平或者垂直切割的方式，对单表进行分表操作。

# 15、
对于生产环境的数据库，程序调用需要使用的账号，给予非root用户的较高的权限。
开发人员、数据分析人员需要用到的查询生产数据的账号，给予select权限。
生产环境中相关的update、insert等的数据修复或者新增数据工作都是由运维采用非root的高权限账号进行。
# 16、
DDL(Data Definition Language)---数据库定义语言（create、alter、drop)，管理基础数据库，例如：库，表  
DCL(Data Control Language)---数据控制语言（grant、revoke、commit、rollback），用户授权，权限回收，数据提交回滚等    
DML（Data Manipulation Language)---数据操作语言（insert、delete、update）,针对数据库里的表，记录 
DQL：Data Query Language --数据查询语言（SELECT）
# 17、
mysql日志一般分为5种
错误日志：-log-error (记录启动，运行，停止mysql时出现的信息)
二进制日志：-log-bin （记录所有更改数据的语句，还用于复制，恢复数据库用）
查询日志：-log （记录建立的客户端连接和执行的语句）
慢查询日志: -log-slow-queries （记录所有执行超过long_query_time秒的所有查询）
更新日志: -log-update （二进制日志已经代替了老的更新日志，更新日志在MySQL5.1中不再使用）
# 18、
如果MySQL服务器突然断电、异常关闭，可能会导致表损坏，无法读取表数据。这时就可以用到MySQL自带的两个工具进行修复，myisamchk和mysqlcheck。
myisamchk：只能修复myisam表，需要停止数据库

常用选项：
-f –force    强制修复，覆盖老的临时文件，一般不使用
-r –recover  恢复模式
-q –quik     快速恢复
-a –analyze  分析表
-o –safe-recover 老的恢复模式，如果-r无法修复，可以使用此参数试试
-F –fast     只检查没有正常关闭的表

快速修复xxx数据库:
# cd /var/lib/mysql/xxx
# myisamchk -r -q *.MYI

mysqlcheck：myisam和innodb表都可以用，不需要停止数据库，如修复单个表，可在数据库后面添加表名，以空格分割
常用参数：
-a  –all-databases  检查所有的库
-r  –repair   修复表
-c  –check    检查表，默认选项
-a  –analyze  分析表
-o  –optimize 优化表
-q  –quik   最快检查或修复表
-F  –fast   只检查没有正常关闭的表

快速修复xxx数据库:
mysqlcheck -r -q -uroot -pxxx xxx

# 19、中文乱码的问题通常是由于没有设定默认字符集引起的，在mysql命令行中设置全局默认的字符集为UTF8。	 
# 20、
事务有4 个隔离级别，分别是：
    读未提交(read uncommit)
    读已提交(read commit)
    可重复读(repeatable read)
    和序列化(serializable)。
      
# 21、主从复制的重点主要有：
1）主库和从库需要设置不同的server-id。
2）主库需要开启binlog日志并确定准确的binlog起始信息。
3）从库在建立主从关系时要指定正确的host、port、user、password、binglog日志信息。

# 22、nosql是所有非关系型数据库的统称。

# 23、在之前工作中一直使用的是zabbix监控软件。

# 24、常见的监控软件有：
• Cacti：是一套基于PHP、MySQL、SNMP及RRDTool开发的网络流量监测图形分析工具。
• Zabbix：Zabbix是一个企业级的高度集成开源监控软件，提供分布式监控解决方案。可以用来监控设备、服务等可用性和性能。
• Open-falcon：open-falcon是一款用golang和python写的监控系统，由小米启动这个项目。
• Prometheus：Prometheus是由SoundCloud开发的开源监控报警系统和时序列数据库(TSDB)。Prometheus使用Go语言开发，是Google BorgMon监控系统的开源版本。

# 25、
1.对系统不间断实时监控
2.实时反馈系统当前状态
3.保证服务可靠性安全性
4.保证业务持续稳定运行
及时发现和解决问题。

# 26、
Zabbix是一个企业级的高度集成开源监控软件，提供分布式监控解决方案。可以用来监控设备、服务等可用性和性能。其主要优势有：
• 自由开放源代码产品，可以对其进行任意修改和二次开发，采用GPL协议；
• 安装和配置简单；
• 搭建环境简单，基于开源软件构建平台；
• 完全支持Linux、Unix、Windows、AIX、BSD等平台，采用C语言编码，系统占用小，数据采集性能和速度非常快；
• 数据采集持久存储到数据库，便于对监控数据的二次分析；
• 非常丰富的扩展能力，轻松实现自定义监控项和实现数据采集。

# 27、
硬件监控、web监控、MySQL监控、服务监控、日志监控

# 28、
Zabbix体系相对清晰，其主要组件有：
• Zabbix Server：负责接收agent发送的报告信息的核心组件，所有配置、统计数据及操作数据均由其组织进行。
• Database Storage：专用于存储所有配置信息，以及有zabbix收集的数据。
• Web interface（frontend）：zabbix的GUI接口，通常与server运行在同一台机器上。
• Proxy：可选组件，常用于分布式监控环境中，代理Server收集部分被监控数据并统一发往Server端。
• Agent：部署在被监控主机上，负责收集本地数据并发往Server端或者Proxy端。

10、全站面试

1、简历怎么写
	3个项目 ---> 详细描述 ---> 画架构图
	k8s部署Php、Java、Python
	例子：
		k8s部署discuz
		本公司主要业务是做长租公寓、其系统架构是由Kubernetes作为底层基础架构，由Jenkins负责迭代，由普罗米修斯（zabbix）负责监控。
		1、拆分成微服务，部署在不同命名空间内，相互之间使用Service别名进行访问。
		2、上层是由nginx Ingress做集群入口
		3、使用阿里云数据库
		4、使用Redis作为缓存数据库
		5、使用ELK作为日志服务器


关于k8s：
	1、怎样将一个应用（PHP、Java、Python、GO）部署到kubernetes中
		软件：kubenrtes、docker、Jenkins、Harbor（阿里云）、Gitlab
		项目部署的步骤：
			1、开评审会议（产品经理、开发、测试、运维、DBA），讨论应用怎么部署
			2、如果是新项目，建立一个代码仓库（gitlab）、设置不同的权限组
			3、在本地测试打包镜像，从而编写出Dockerfile，（尽量减少容器的体积busybox，不建议使用CentOS）
			4、规划集群网络
			5、使用自由风格、pipline编写jenkinsfile（Blue Ocean），测试部署
			6、部署不同的环境（调试环境（dev）、测试环境(test)、预发布环境(pre)、生产环境(master)）	
				6.1、Jenkins链接k8s的方法
					1、使用证书
					2、使用kubeconfig
					3、使用kubectl的--kubeconfig参数
			7、测试部署的各个功能
			8、提交给测试及开发使用

		应用部署的流程：
			PHP：
				1、建立一个自由风格的项目
				2、使用参数化构建（比喻说：不同的git tag部署（仅限于生产环境，其他环境还是用于分支部署））
				3、构建（根据代码的不同，做对应的操作[根据开发的要求，例如：composer]）
				4、构建后操作（相当于把代码部署过去）
				5、测试（测试对应的链接访问是否成功）
				6、发部署成功邮件
				
				7、在每次发布代码之前，要开评审会议
					1、发布的步骤（先修改数据库还是先发布代码）
					2、确定发布的服务有哪些
			JAVA：
				编译环境
				部署环境
				
			Python:
				
			GO:
				编译环境

		Jenkins部署到k8s的方式：
			1、自由风格
				1、基础部分（例如：参数化构建）
				2、源代码管理（git）
				3、构建（编译代码、打包镜像、上传至镜像仓库）
				4、构建后操作（kubectl set image）
			2、pipline
				原则：不同的操作，处于不同的容器（编译代码、打包镜像、升级服务）
				1、编写Jenkinsfile
					1、JLNP（jenkins agent）
					2、Jenkinsfile怎么写的
						1、基础环境
							1、k8s
							2、docker
							3、any(当前服务器)
						2、按照步骤来分
							1、源代码管理
							2、编译代码
							3、打包镜像
							4、部署
							5、测试
							6、发邮件
				2、创建流水线项目
					根据不同的分支，使用不同的jenkinsfile，部署不同项目
	2、k8s中的各个组件及其协同关系
		1、master节点
			apiserver(CPU)
			控制器
			调度器
			网络插件
			DNS
			kubelet
			kube-proxy
			ETCD
			
			kubectl
		2、worker节点
	
	3、pod的生命周期
		1、调度到对应的节点,从而创建Pod成功
		2、创建主容器，然后依次创建业务容器（kubelet、kube-proxy，主容器：pause）
		3、执行开始回调钩子（controler-manager, kubelet）
			1、exec
			2、httpGet
			3、tcpSocket
		4、进行健康检查（伴随着整个生命周期）
		5、执行结束回调钩子
		6、结束业务容器
		7、结束主容器
		8、删除pod,是否资源

	4、flannel和calico之间的区别，你们用的是哪一个，为什么？
		两者都属于k8s网络插件。我们公司使用的是flannel, calico性能更好也更灵活，但是flannel更加简单好用，当公司由二次开发kubernetes的场景时，建议使用calico，当有IPV6使用场景时，必须使用calico。

	5、k8s怎么暴露一个服务
		NodeProt、loadbalancer

	6、k8s中，你是怎么控制调度的
		1、pod亲和性
		2、nodeSelect

	7、k8s权限
		k8s支持多种权限，最常用的时RBAC（角色、权限组、用户）、然后通过集群权限绑定和校色绑定的方式ServiceAccounts绑定到集群

	8、怎样监控一个k8s中的应用
		使用普罗米修斯来监控的，对于普罗米修斯来说，监控一个应用只需要一个metrics接口，但是应用市场上用携带metrics接口的服务也有不携带metrics的服务。
		首先监控携带metrics的服务，分两种情况：
			1、一种是容器化的普罗米修斯
				1、创建一个EndProints（将外部的应用的metrics接口的地址接入集群）
				2、创建跟上条的EndPrints同名称的Service
					1、只有创建service跟endproints同名称才能够关联上
					2、将endPrints接入的地址，通过service交给集群使用
				3、部署ServiceMonitor
					1、将上述接入集群的service中的需要被监控的metrics接口注入到普罗米修斯
				
			2、另一种部署到宿主主机上的普罗米修斯
				1、将metrics接口地址写入普罗米修斯配置文件
				2、重启普罗米修斯
		监控不携带metrics的服务，分两种情况：
			1、一种是容器化的普罗米修斯
				1、创建一个EndProints（将外部的应用的metrics接口的地址接入集群）
				2、创建跟上条的EndPrints同名称的Service
					1、只有创建service跟endproints同名称才能够关联上
					2、将endPrints接入的地址，通过service交给集群使用
				3、部署exporter,构建出一个metrics接口（1和2步合并进来）
				4、部署ServiceMonitor
					1、将上述接入集群的service中的需要被监控的metrics接口注入到普罗米修斯
				
			2、另一种部署到宿主主机上的普罗米修斯
				1、部署exporter,构建出一个metrics接口
				2、将metrics接口地址写入普罗米修斯配置文件
				3、重启普罗米修斯

关于Redis:
	1、关于集群
		1、redis主从（1主3从）
			优点：简单
			缺点：
				1、数据备份过多，浪费资源
				2、不会自动故障转移
				
		2、redis哨兵：是在redis主从上增加了一个监控
			优点：支持故障转移
			缺点：
				1、数据备份过多，浪费资源
		3、redis cluster
			优点：
				1、支持故障转移
				2、数据备份量少，节省资源
				
			缺点：
				1、不会自动分配卡槽

	2、关于持久化
		1、RDB
			原理：是将数据保存成二进制文件，
			优点：
				1、性能好
				2、保存的数据体积小
			缺点：
				1、会丢部分数据
		2、AOF
			原理：将Redis中的执行的命令保存下来
			优点：
				1、不会丢数据
			缺点：
				1、性能差
				2、保存数据体积大
				
		3、RDB + AOF
			原理：两者皆支持
			优点：
				1、性能好
				2、保存的数据体积小
				3、不会丢数据
	3、优化
		优化有套路：磁盘IO和网络IO
			ssd   硬件网卡  内存多 redis本身的优化（参数优化、系统参数优化）
			net.ipv4.tcp_keepalive_time = 600
            net.ipv4.tcp.keepaliv.probes = 3
            net.ipv4.tcp_keepalive_intvl = 15
            net.ipv4.tcp.max_tw_buckets = 36000
            net.ipv4.tcp_tw_reuse = 1
            net.ipv4.tcp.max_orphans = 327680
            net.ipv4.tcp_orphan_retries = 3
            net.ipv4.tcp_syncookies = 1
            net.ipv4.tcp_max_syn_backlog = 16384
            net.ipv4.ip_conntrack_max = 65536
            net.ipv4.tcp_max_syn_backlog = 16384
            net.ipv4.top_timestamps = 0


关于ELK：
	E:elasticsearch(数据库)
	L:logstash（筛选器）
	K:kibana（展示器）
	
	elasticsearch的运行原理：将热数据存放在内存，
	
	1、你们公司每天的日志量
	
	20G
	
	pv ： 6000w
	uv ： 2000
	QPS: 10~20W
	
	2、ELK的存储有多少
		2T的数据
	
	3、ELK的架构是什么
		1、主从（查询的数据要慢一些）
		2、冷热分离节点（热数据：4[8核16G，硬盘ssd 1T ]， 冷数据：2[2核4G, 机械硬盘10T] ）
	
	4、你在哪些场景中使用了ELK
		1、订单
			1、支付完成之后，不会立即查询到支付结果，request_cache=ture
		2、搜索
			1、脑裂
		3、日志
			1、查询1000以后，查询不到数据

	5、你在使用ELK过程中遇到哪些问题
		
关于数据库：
	1、某种偶发情况下，在从节点上写入了一条数据
		1、主从切换
		2、删除出问题的从节点，清空其数据，从加入集群
	2、数据库优化
		硬件的优化
		网络的优化
		数据库内存，线程
		innodb内存优化
		存储引擎
		SQL优化
		
		explain，来查询SQL索引命中率
		优化索引
		
	
其他的面试题：
	PV ：6000w
	UV : 2000
	QPS: 10~20W
	数据库 QPS : 10~20W
	redis QPS : 30~40W
	
	tomcat和java的优化：
		jvm 堆和栈优化
		jvm 线程优化
		jvm 内存优化

公司介绍：
	
	上海十维科技有限公司
	上海楚辰科技有限公司

	长租公寓，
		官网
		内部考勤系统
		定时任务平台
		客户系统
		CRM : 管理销售合同
		PMS ：客户管理系统
		配置中心（阿波罗）
		SQL管理平台
		财务管理系统（做报表）
		监控系统（普罗米修斯）
		员工管理系统



工作内容的介绍：

	巡检、处理报警、引入新技术、配合其他同事部署新环境、编写优化方案、处理紧急事务、发布代码（dev自动发布,test环境和pre环境是测试同事发布，master环境专门的运维发布（每周四下午6点发布代码））

涉及保密协议的介绍：设计敏感信息直接拒绝