美团5.22运维

image-20240525012017976

1.在Nginx配置文件中，alias指令只能写在什么模块中？

1
alias 指令通常用在 location 块中来指定存取静态文件的路径。

Nginx配置文件结构

img 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
nginx配置文件主要分为四个部分：

main（全局设置）
http ( )
upstream（负载均衡服务器设置）
server（主机设置）
location（URL匹配特点位置的设置）

server部分的指令主要用于指定主机和端口，
upstream指令主要用于负载均衡和设置一系列的后端服务器，
location部分用于匹配网页位置位置。

    upstream backend {
        server 127.0.0.1:8082 max_fails=5 fail_timeout=10s weight=1;
        server 127.0.0.1:8081 max_fails=5 fail_timeout=10s weight=1;
    }

2.数据库设计的实体类关系的陷阱问题

1
2
3
4
5
6
链接陷阱问题：
两个实体通过第三个实体间接关联时，
而这三个实体之间的关系却没有正确反映这种间接关系的真实情况。
这种陷阱常发生在连续的一对多关系中，
如果在查询中不小心处理这些关系，
可能会导致数据的重复计算或错误的统计结果。

3.vim的命令

1
2
：wq        保存退出

4.Zabbix

1
2
3
Zabbix 是一个高度集成的开源监控解决方案，
用于监控和跟踪服务器的状态、网络设备、虚拟机
以及其他各种网络服务的性能和可用性

5.Linux通配符

1
2
3
4
5
6
7
通配符是用来匹配文件和目录名中的字符的特殊符号。
这些通配符可以在许多命令行工具中使用，
如 ls, cp, mv, rm, grep 等，以简化文件管理和搜索任务
*
？
[]
{}

笔试题1：

构造长度为n的，仅有小写字母组成的字符串，恰好包含a个mei，b个tuan的子串

输入：n a b

输出：字符串，无解输出-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*思路：3*a + 4*b > n的时候无解
    先构造a，个mei，b个tuan
    其余长度随便拼接个子串就行*/
package meituan;

import java.util.*;

public class Main01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int a = scanner.nextInt();
        int b = scanner.nextInt();

        String s = function(n, a, b);
        System.out.println(s);
    }

    private static String function(int n, int a, int b) {
        if (a * 3 + b * 4 > n) {
            return "-1";
        }
        StringBuilder sb = new StringBuilder();
        while (a > 0) {
            sb.append("mei");
            a--;
        }
        while (b > 0) {
            sb.append("tuan");
            b--;
        }
        while (n > sb.length()) {
            sb.append("a");
        }
        return sb.toString();
    }
}

笔试题2：

数组爆炸

小妹拿到一个数组，每次的爆炸操作为：删除该元素以及其两侧元素

小妹只能操作两次爆炸

希望爆炸之后的元素尽可能小

输入：n（数组长度）

​ n个数组元素

输出：整数，最小元素和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*思路：每次爆炸少三个元素，两次少6个元素，数组长度＜6的直接返回0
	因为数组都是正数，要确保和最小，就不能删除首尾的元素，所以数组长度＜6的最小和都为0，其次，使用贪心算法，在第一次找到最小值，删除元素的基础上，再进行第二次爆炸，两次爆炸的代码完全可以复用，只是数组长度不一样了，
*/
//先暴力算法
package meituan;

import java.util.*;

public class Main02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        if (n <= 6) {
            System.out.println(0);
            return;
        }
        scanner.nextLine();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        long sum = 0;
        for (int i = 0; i < n; i++) {
            sum += arr[i];
        }
        //第一次爆炸取最小和
        long minSum = sum;
        for (int i = 1; i < n - 1; i++) {
            long temp = sum - arr[i] - arr[i - 1] - arr[i + 1];
            minSum = Math.min(temp, minSum);
        }
        //在计算两次爆炸后的最小和
        for (int i = 1; i < n - 1; i++) {
            long temp = sum - arr[i] - arr[i - 1] - arr[i + 1];
            for (int j = i + 3; j < n - 1; j++) {
                long temp2 = temp - arr[j] - arr[j - 1] - arr[i + 1];
                minSum = Math.min(minSum, temp2);
            }
        }
        System.out.println(minSum);
    }
}

笔试题3

小美有一颗n节点的树，根节点为1号节点，数的每个节点是红色或者黑色的，她想知道有多少节点的子树中，同时包含红点和黑点

输入描述：

第一行输入n个整数，表示节点的数量

第二行输入长度为n的字符串表示节点的颜色，第i个节点的颜色表示si，B表示黑色，R表示红色

接下来，n-1行，输每行输入两个整数，u,v，表示树上的边

输出描述：输出一个整数表示答案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
//思路：树的子树表示：包含自身和其后代所有节点
//定义树的结构，，用颜色和，用邻接表表示
//深度优先遍历，从根节点开始，遍历整个树，在遍历的过程中，收集每个节点的子树中的颜色信息
//对于每个节点，我们要知道子树中是否含有红黑色节点，维护两个布尔值，分别记录红黑是否存在
//最后判断，在递归返回的过程中，检查每个节点的字数，如果同时包含，就增加计数器

import java.util.*;

class Node {
    List<Node> children = new ArrayList<>();
    char color;
}

public class Main04 {
    private static int count = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        scanner.nextLine();
        String colors = scanner.nextLine();
        //创建n+1个节点，是为了一一对应
        Node[] nodes = new Node[n + 1];
        for (int i = 1; i <= n; i++) {
            nodes[i] = new Node();
            nodes[i].color = colors.charAt(i - 1);
        }
        for (int i = 1; i < n; i++) {
            int u = scanner.nextInt();
            int v = scanner.nextInt();
            nodes[u].children.add(nodes[v]);
            //nodes[v].children.add(u);
        }
        scanner.close();
        //深度遍历
        dfs(nodes[1]);
        System.out.println(count);
    }

    private static boolean[] dfs(Node node) {
        boolean[] contains = new boolean[2];
        if (node.color == 'R') {
            contains[0] = true;
        } else {
            contains[1] = true;
        }
        for (Node child : node.children) {
            boolean[] childContains = dfs(child);
            contains[0] = contains[0] || childContains[0];
            contains[1] = contains[1] || childContains[1];
        }
        if (contains[0] && contains[1]) {
            count++;
        }
        return contains;
    }
}

美团牛客面经

谈谈你对运维的理解

1
2
3
4
5
6
7
8
我的理解是，运维工程师就是
把开发写好的工程，去部署，发布，维护，监控，事件处理
确保系统的稳定运行
以及应对突发的处理情况
因为一般都是部署在Linux中，
需要对Linux比较了解
还需要对监控软件zabbix
自动化部署k8s等有所了解

1，介绍OSI七层网络模型

1
2
3
4
5
6
7
应表会传网数物：应用层，表示层，会话层，传输层，网络层，数据链路层，物理层
TCP/IP四层模型：应用层，传输层，网络层，网络接口层

HTTP协议：基于tcp协议，超文本传输协议，主要用在Web浏览器与服务器之间通信的

TCP是可靠协议，建立连接需要三次握手，传输后需要释放链接，数据包损坏会重传
UDP是不可靠协议，不需要传输前建立连接，适用于对传输速度和效率要求高且能容忍少量数据丢失的应用，如视频流（直播）、在线游戏

2.zabbix软件，k8s

1
2
3
zabbix主要用于监控服务器的性能，网路流量，和设备状态
我了解一些，但是没用到过
k8s是kubernetes，用于自动化部署容器，扩展和容器化应用程序

3.Nginx调度算法

1
2
3
4
5
6
7
8
9
10
11
12
轮询，权重轮询，最少连接数，最短相应时间等
在Nginx的配置文件中的upstream backed修改配置

我自己布置Nginx的步骤，
主要是启动Nginx然后对Nginx的配置文件的配置
包括监听的端口，
反向代理的地址
还有就是负载均衡分给服务器的端口

反向代理就是，将客户端的请求，分给多台后端的Web服务器。
提升网站的负载能力和可靠性，代理的是服务器
正向代理就是：就像有个中介代理服务器一样，他代理的是客户端

4，MySQL的主从，数据库高可用

1
2
3
4
5
6
7
8
9
10
11
12
主从复制吗？
主服务器主要负责写操作，insert，delete，update
并且记录所以得写操作到二进制日志，binlog中

从服务器复制binlog，写入到中继日志中去，
从库的SQL线程读取中继日志的文件
更新服务器的数据

主从复制的类型：异步复制，半同步复制，同步复制

数据库高可用就是，数据库系统出现故障的时候，能够保证持续的可用性和可靠性
包括：冗余备份，故障检测，负载均衡，数据备份与恢复，监控警报等

5.HTTP的状态码

1
2
3
4
5
1XX：临时响应
2XX：成功
3XX：重定向，需要后续操作才能
4XX：客户端错误，403拒绝，404找不到
5XX：服务器错误

6.长连接和短链接

1
2
3
4
5
长连接：完成通信不关闭，保持一段时间，持久连接，HTTP1.1，Web socket
	一般请求频率高，场景
短连接：每次都建立新链接，HTTP1.0
	请求频率低的场景

7.数据库表的设计注意什么

1
2
3
4
5
6
7
8
那很多细节了
1,数据库设计的三个范式，每个列，每个非主键都依赖于主键
2.主键的设置
3，外键的设计
4.实体关系图的设计
5.索引的设计
6.合适的数据类型
7.大表的优化，分区分表等

8.进程和线程

1
2
3
4
一个进程中包含很多线程
进程是一个独立运行的程序，
线程是进程内的一个独立的执行单元
一个进程包含多个线程

9.谈谈你对运维的理解

1
2
我的理解就是，应用系统的发布，维护，监控，事件处理
对相关故障的排查等，对Linux要有比较深入的了解

10，反问

1
2
3
我知道今天的表现可能不尽如人意
您可以从面试官的角度给我一些后续的建议
或者说规划吗

11.ELF的链接过程

1
2
3
4
5
6
ELF是将分散的目标文件合并成一个可执行文件的过程
1.编译和汇编
2.符号解析
3.定位
4.合并
5.生成可执行文件

12.PIE是什么

1
2
PIE，位置无关可执行文件，它的代码可以在内存中的任何位置执行，
而不会依赖于特定的内存地址。这种技术在增强安全性和灵活性方面具有重要意义。

13.对云原生的理解

1
2
3
4
5
6
7
不仅仅是将应用部署在云上，而是用云的特性来优化开发和运营流程
比如说：
容器化，将应用及其依赖环境打包成一个独立的镜像，
	运行在容器中，确保在不同的环境中也能一致的运行
微服务架构：将应用拆分成小的，独立部署的服务
	每个专注与特定的功能
动态编排：使用编排工具，kubernetes，自动化的管理资源，故障修复，简化管理等

14，什么样的服务适合在云上跑

1
2
适合在云上运行的服务有以下共同的特征：
需要高弹性和可扩展性，对成本敏感，需要快速部署和调试

15.有状态服务和无状态服务的差异

1
2
3
无状态服务：就是每个请求是独立的，服务端不会保存有关客户端的信息
有状态服务：就是，服务器会在会话请求中保存客户端的状态信息
		会话跟踪技术就是，cookie，session，jwt

16.数据库云上，云下区别，（云端部署和本地部署）

1
2
3
4
5
6
7
8
就是数据库部署在本地与云端的区别
本地的话：就是需要自己去购买服务器，自行搭建，云端不会
然后本地的话，本地团队管理，要投入大，云端不会

性能方面：主要是延迟，这个本地的延迟肯定低
安全方面：本地部署的难免遇到不可抗力，云端有多个服务器，主从，哨兵模式，
		挂了，会有其他节点顶上
扩展：本地的难扩展，要买设备，云端的只需要花钱买买买就行了

17.Linux命令问题

1
搜索：使用grep搜索

18.shell的指令

1
2
3
4
5
6
7
Shell命令是进行系统操作、文件管理、进程管理、网络操作等各种任务的基础
文件操作：ls,ll,pwd,madir,rm,cp,mv,cat
文件权限和所有权：chmod
文件查找：find，grep
系统管理：kill，df,ps,du
网络操作：ping,ipconfig,netset
解压安装：tar

19.shell脚本

1
2
3
首先去创建一个.sh结尾的文件,nano example.sh
去把一系列的shell指令写进去
运行脚本：./example.sh即可

20.ls是怎么筛选排序的

1
默认是按照字母的顺序，可以使用一些选项，-l,-r,-t等等可以按照不同的顺序排序

21.DNS域名解析

1
2
使用域名解析，根据域名解析出相应IP地址
底层是递归解析吧，查询顶级域名，查询权限域名，返回结果

22.Linux系统的内存结构

1
2
3
4
5
内核空间：
用户空间：
缓存区和缓冲区：
内存映射区：
呢内存线程栈：

23.Linux系统如何查看当前CPU占用？内存占用？

1
2
top查看CPU占用
free查看内存占用

24.Linux系统的$符号的作用

1
2
占位符
变量的引用，环境变量的引用，命令的替换

25.TCP三次握手，四次挥手，为什么挥手最后一次要等待？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
三次握手的过程是为了确保客户端和服务器双方都能够正常发送和接收数据：

第一次握手：客户端向服务器发送一个带有SYN标志的数据包，请求建立连接。
第二次握手：服务器收到客户端的SYN后，回复一个带有SYN/ACK标志的数据包，表示接受连接请求。
第三次握手：客户端收到服务器的SYN/ACK后，再次回复一个带有ACK标志的数据包，表示连接建立成功。
这样，通过三次握手，客户端和服务器双方都确认了彼此的接收和发送能力，建立了可靠的TCP连接。

2. 四次挥手（TCP连接终止）
四次挥手的过程是为了确保客户端和服务器双方都能够正确地关闭连接，并且保证数据的完整性：

第一次挥手：客户端向服务器发送一个带有FIN标志的数据包，表示客户端不再发送数据。
第二次挥手：服务器收到客户端的FIN后，回复一个带有ACK标志的数据包，表示已经收到了客户端的关闭请求。
第三次挥手：服务器向客户端发送一个带有FIN标志的数据包，表示服务器也准备关闭连接。
第四次挥手：客户端收到服务器的FIN后，回复一个带有ACK标志的数据包，表示已经收到了服务器的关闭请求，并且也准备关闭连接。
在四次挥手的最后一次挥手之后，客户端和服务器会进入TIME_WAIT状态，等待一段时间后才会完全关闭连接。这个等待时间是为了确保网络中所有的数据包都能够被正确地传输完成，以防止数据丢失或者重复传输。等待时间结束后，连接才会完全关闭，释放所有资源。

26，死锁是怎么形成的

1
2
多个线程竞争资源导致的阻塞状态，每个线程都在等待其他线程释放资源，
导致所有的参与者都无法访问

27.文件权限755

1
2
3
4
5
6
7
8
这个是由三种不同的权限标识的数字
分别是，所有者权限，所属者权限，其他用户权限
读权限是：4
写权限是：2
执行权限是：1

因此，755，就是，所有者有读，写，执行，所属着和其他用户为读+执行

28，目录权限和文件权限的执行不同

1
2
3
4
5
执行权限的含义不同：对于文件，执行权限表示是否可以执行该文件；
对于目录，执行权限表示是否可以进入该目录。
写权限的作用不同：对于文件，写权限表示是否可以修改文件内容；
对于目录，写权限表示是否可以修改目录结构，包括创建、删除和重命名文件和子目录。

29，swap

1
2
顾名思义，交换嘛，swap，用于在内存RAM不足的情况下
将swap空间作为虚拟内存的一部分磁盘空间

30.对Linux异常监控跟踪

1
2
3
4
日志监控：syslog
系统性能监控：top(CPU)，free(内存)
进程监控：ps
网络监控：netstat等

30.防止巨大流量冲击的防护措施有什么

1
防火墙，IP封堵黑白名单，cdn加速把静态资源存到全球各地的节点