2026 DevOps + AWS 面试

1. 你部署过哪些类型的应用？

Web 应用 (例如，Java Spring Boot， Node.js)，
微服务架构，
数据库 (例如， MySQL, MongoDB)，
消息代理 (例如， Apache Kafka)，
监控工具 (例如， Prometheus, Grafana)，
CI/CD 流水线 (例如， Jenkins)，
使用 Docker 和 Kubernetes 的容器化应用

2. 你如何将 secrets 注入到 ConfigMaps 中？

Secrets 不应注入到 ConfigMaps 中，因为 ConfigMaps 并非为敏感数据设计。

应使用 Kubernetes Secrets。Secrets 可以通过环境变量注入到 pods 中或挂载为文件。

3. 你如何使用 kubectl 查找哪个 pod 在跨节点上占用更多系统资源？

使用

kubectl top pod --all-namespaces

来列出 pods 的资源使用情况。

结合使用 kubectl describe pod <pod-name> 来获取详细的资源使用情况。

4. 你如何使用 kubectl 了解集群中哪个工作节点消耗更多资源？

使用 kubectl top nodes 来查看各节点的资源消耗。

这将显示每个节点的 CPU 和内存使用情况。

5. 配置 Prometheus 和 Grafana 监控 Kubernetes 集群的步骤是什么？

使用 Helm 或自定义 YAML 配置部署 Prometheus。
为 Prometheus 设置 Kubernetes 服务发现。
部署 Grafana 并配置其使用 Prometheus 作为数据源。
在 Grafana 中导入 Kubernetes 监控仪表板。
根据需要，在 Prometheus 中设置告警规则

6. 如果有 20 个 pods 在运行，你如何在 Grafana 中可视化这些 pods 的指标？

配置 Grafana 使用 Prometheus 作为数据源。使用现有的 Kubernetes 仪表板或创建自定义仪表板来可视化所有 pods 的指标。

7. 什么是 Apache Kafka？

Apache Kafka 是一个分布式事件流处理平台，用于构建实时数据管道和流式应用。它设计用于以分布式、容错的方式处理大量数据。

8. 你如何设置 Docker Hub 私有仓库并将其与 CI/CD 流水线集成？步骤是什么？

在 Docker Hub 上创建私有仓库。
配置 CI/CD 流水线以使用凭据向 Docker Hub 进行身份验证。
在 CI 流水线中构建 Docker 镜像并将其推送到私有仓库。
在 CD 过程中从私有仓库拉取镜像。

9. 硬链接和软链接之间有什么区别？

硬链接：对磁盘上文件数据的直接引用。

删除原始文件不会影响硬链接。

软链接（符号链接）：指向原始文件路径的指针。

如果原始文件被删除，软链接将失效。

10. shell 脚本中 break 命令的用途是什么？你在什么场景下使用过它？

break 命令用于提前退出循环。通常在满足特定条件且不再需要继续循环时使用。

11. 你如何统计 15 个 HTML 文件中 "devops" 单词的数量？

要统计 15 个 HTML 文件中 "devops" 单词出现的次数，可以使用以下 shell 命令：

grep -o -i "devops" *.html | wc -l

grep -o -i "devops" *.html: 在所有 HTML 文件中搜索单词 "devops"（-i 表示不区分大小写），并将每个匹配项单独输出一行（-o）。
wc -l: 计算 grep 输出的行数，即 "devops" 出现的次数。

12. 什么是 terraform taint 命令？

terraform taint 命令用于在下一次 terraform apply 时手动标记特定资源需要重新创建。

当一个资源被标记为 tainted 后，Terraform 将在下次 apply 时销毁它并创建一个新的实例。

这在你知道某个资源需要替换但 Terraform 未自动识别时很有用。

语法: terraform taint <资源地址>
示例: terraform taint aws_instance.example

13. 在 Terraform 中保护 state 文件的可能方法有哪些？

加密 State 文件：使用诸如 AWS S3 桶加密、Azure Blob 加密或 Google Cloud Storage 加密等工具以加密格式存储 state 文件。
使用具有安全控制的远程后端：使用如带有 IAM 角色和策略的 AWS S3、带有 ACLs 的 HashiCorp Consul 或管理访问控制和加密的 Terraform Cloud 等远程后端。
启用版本控制：在 state 文件存储上使用版本控制，以便从任何意外的更改或删除中恢复。
访问控制：使用 IAM 策略、RBAC（基于角色的访问控制）或类似机制限制对 state 文件的访问。
使用后端锁定：使用后端（如带有 DynamoDB 的 S3 或 Consul）提供的 state 锁定机制，以防止并发操作破坏 state 文件。

14. 如果你配置了 100 台服务器，有人手动删除了其中 50 台 VMs，那么当你执行 terraform apply 命令时会发生什么？

当你运行 terraform apply 时，Terraform 会将 state 文件与实际基础设施进行比较。

它会发现有 50 台 VMs 缺失，并会尝试重新创建这些缺失的 VMs，以匹配你配置中定义的状态。

最终结果将恢复到 100 台 VMs。

15. Terraform 中 for_each 的语法是什么？

Terraform 中的 for_each 元参数允许你基于映射或集合中的项创建多个资源或模块实例。

语法如下：

resource "aws_instance" "example" {
  for_each = var.instances
  ami = each.value["ami"]
  instance_type = each.value["instance_type"]
  tags = {
    Name = each.key
  }
}

在这个例子中，var.instances 是一个映射，each.key 指的是映射中当前的键，而 each.value 指的是关联的值。

16. Docker 中多阶段构建的优点和缺点是什么？

优点

更小的镜像大小：通过将构建环境与运行时环境分离，最终镜像中只包含必要的组件，从而减小镜像大小。
提高安全性：通过从最终镜像中排除构建工具和其他不必要的组件，减少了攻击面。
更好的缓存：可以更有效地利用 Docker 的缓存机制，可能加快构建过程。
关注点分离：不同的阶段可以专注于特定任务，使 Dockerfile 更有条理且易于维护。

缺点

复杂性：多阶段 Dockerfile 可能更复杂，更难以理解，尤其对 Docker 新手而言。
更长的构建时间：在某些情况下，使用多个阶段可能导致更长的构建时间，因为需要额外的步骤和阶段间切换。
故障排除：调试和故障排除可能更具挑战性，因为默认情况下中间阶段不会被保留。

17. 你如何在 Docker 集群内将容器部署到不同的主机上，而不是同一台主机？

要在 Docker 集群内将容器部署到不同的主机上，可以使用 Docker Swarm 或 Kubernetes。

Docker Swarm：使用 Docker Swarm 内置的编排能力。

部署服务时，Swarm 会自动将容器分布在集群中的不同节点上。你可以使用放置约束来影响此行为。

示例：

docker service create --name myservice --replicas 2 --constraint 'node.role == worker' myimage

Kubernetes：使用 Kubernetes，它会根据可用资源以及任何指定的节点选择器或亲和性，将 pods 调度到不同的节点上。

18. 如果你有一个 Docker Compose 设置，如何将 web 容器部署在一台主机上，将 DB 容器部署在另一台主机上？

要使用 Docker Compose 将 web 容器部署在一台主机，将 DB 容器部署在另一台主机上，你可以：

使用 Docker Swarm：将 Compose 文件转换为 stack 文件，并使用 docker stack deploy 进行部署。Docker Swarm 将服务分布在节点上。

手动放置：在你的 docker-compose.yml 文件中使用放置约束来指定哪些容器应该在哪些节点上运行。

version: '3.7'
services:
  web:
    image: my-web-image
    deploy:
      placement:
        constraints: [node.hostname == web-node]
  db:
    image: my-db-image
    deploy:
      placement:
        constraints: [node.hostname == db-node]

19. Docker 中桥接网络和主机网络有什么区别？

桥接网络：默认的 Docker 网络驱动。

连接到同一桥接网络的容器可以相互通信。
每个容器获得自己的 IP 地址，并与主机网络隔离。你可以使用 -p 选项将端口暴露给主机。

主机网络：容器共享主机的网络栈，

意味着它没有自己的 IP 地址，容器的网络与主机的网络相同。
这可以提高性能，但降低了主机与容器之间的隔离性。

20. 你如何解决合并冲突？

解决合并冲突的步骤如下：

识别冲突：Git 将使用冲突标记（<<<<<<<， =======， >>>>>>>）标记文件中的冲突区域。
手动解决：打开冲突文件，决定如何合并更改。移除冲突标记并修改内容以解决冲突。
暂存已解决的文件：解决后，使用 git add 暂存文件。
提交更改：使用 git commit 提交已解决的冲突。如果你正处于合并过程中，这将完成合并过程。
测试：运行测试以确保合并没有引入任何问题。

git add <已解决的文件>
git commit -m "已解决 X, Y, Z 文件中的合并冲突"

21. 你使用什么命令来更改现有的提交信息？

要更改最近的提交信息，可以使用以下 Git 命令：

git commit --amend -m "新的提交信息"

如果已经将提交推送到远程仓库，则需要强制推送更改：

git push --force

22. 什么是会话亲和性？

会话亲和性，也称为粘性会话，是负载均衡中的一个概念，即来自特定用户的请求在有多服务器的环境中被持续定向到同一台服务器（或 pod）。

这确保了用户存储在服务器本地的会话数据在整个会话期间保持可访问性。

23. 什么是 Pod 亲和性及其用例？

Pod 亲和性是 Kubernetes 中的一项功能，允许你为 pod 调度指定规则，使其运行在已经运行了其他指定 pods 的节点上。

当你希望某些 pods 由于数据局部性、网络延迟或共享资源等因素而位于一起时，这可能很有用。

用例：一个前端和后端服务频繁通信的应用程序可能会使用 Pod 亲和性来确保两者被调度到同一节点，以减少网络延迟。

24. Pod 亲和性和 Pod 反亲和性有什么区别？

Pod 亲和性：确保 pods 被调度在同一节点上或彼此邻近。

Pod 反亲和性：确保 pods 不被调度在同一节点上或彼此远离

示例用例：

Pod 亲和性：为了低延迟通信，将前端和后端运行在同一节点上。

Pod 反亲和性：确保同一应用的副本分布在不同的节点上，以提高可用性和容错能力。

25. 什么是就绪探针和存活探针？

就绪探针：用于确定 pod 何时准备好开始接收流量。如果就绪探针失败，pod 将从服务端点中移除，确保其在准备就绪之前不会接收流量。

存活探针：用于确定 pod 是否仍在运行。如果存活探针失败，Kubernetes 将重启该 pod，假设其处于故障状态。

26. 请为一个 Java Spring Boot 应用编写一个简单的 Groovy 流水线，该流水线等待用户输入批准以进入下一阶段，阶段包括代码检出、构建、推送和部署

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/your-repo/java-spring-boot-app.git'
            }
        }
        stage('Build') {
            steps {
                sh './mvnw clean package'
            }
        }
        stage('Push') {
            steps {
                sh 'docker build -t your-docker-repo/java-spring-boot-app .'
                sh 'docker push your-docker-repo/java-spring-boot-app'
            }
        }
        stage('Approval') {
            steps {
                input 'Do you want to deploy to production?'
            }
        }
        stage('Deploy') {
            steps {
                sh 'kubectl apply -f deployment.yaml'
            }
        }
    }
}

27. 你如何在 Jenkins 中导出测试报告？

要在 Jenkins 中导出测试报告：

确保你的测试以标准格式（如 JUnit XML 或 HTML）生成报告。
使用 "Publish JUnit test result report" 构建后操作来归档测试报告。
你还可以使用 "Archive the artifacts" 构建后操作来存储其他类型的报告。
测试报告随后可以从 Jenkins 构建页面访问和下载。

28. 如果有 5 个 pods 在运行，你如何使用 Kubernetes 命令行将 pods 数量扩展到 10 个？

要将 pods 数量从 5 个扩展到 10 个，使用以下命令：

kubectl scale --replicas=10 deployment/<你的部署名称>

29. 你能解释一下 terraform import 命令的用法吗？

terraform import命令用于将现有的基础设施资源导入到 Terraform 的 state 文件中，以便 Terraform 对其进行管理。

当你想要在不重新创建资源的情况下，将现有基础设施纳入 Terraform 管理时，这特别有用。

terraform import <资源类型>.<资源名称> <资源ID>

terraform import <resource_type>.<resource_name> <resource_id>

terraform import aws_instance.my_instance i-1234567890abcdef0

30. 在 AWS 中，你将 state 文件存储在哪里，以及如何管理它？

在 AWS 中，Terraform state 文件通常存储在 S3 桶中，并且可以使用 S3 和 DynamoDB 的组合进行锁定管理。

示例配置：

terraform {
  backend "s3" {
    bucket = "my-terraform-state-bucket"
    key = "path/to/my/terraform.tfstate"
    region = "us-west-2"
    dynamodb_table = "terraform-lock-table"
    encrypt = true
  }
}

管理

S3：安全地存储 state 文件，支持版本控制，并且可以加密。

DynamoDB：提供锁定机制，防止对同一 state 文件进行多个并发操作，避免冲突。

此设置确保你的 Terraform state 被安全存储，并受到防止并发访问问题的保护。

31. 你在使用 Terraform 时遇到的最大问题是什么，你是如何解决的？

我遇到的一个主要问题是当多个团队在同一基础设施上工作时管理 Terraform state。

这通过将基础设施组织成独立的模块以及使用带有适当锁定机制的远程 state 管理得以解决。

32. AWS S3 中有哪些类型的存储类别？

在 AWS S3 中，不同的存储类别包括：

S3 Standard
S3 Intelligent-Tiering
S3 Standard-IA (不频繁访问)
S3 One Zone-IA
S3 Glacier
S3 Glacier Deep Archive

33. 你熟悉 S3 桶的生命周期管理吗？如何设置生命周期策略？

是的，S3 生命周期管理允许你定义规则，在特定时间段后将对象在不同存储类别之间转换或将其删除。

可以通过 S3 管理控制台、AWS CLI 或 Terraform 来设置生命周期策略，即在 JSON 配置文件中指定转换和过期操作。

34. 负载均衡器之间有什么区别，为什么我们需要它们？

负载均衡器将传入的网络流量分配到多台服务器。主要类型有：

应用负载均衡器 (ALB)：在应用层（第7层）运行，用于具有高级路由功能的 HTTP/HTTPS 流量。
网络负载均衡器 (NLB)：在传输层（第4层）运行，用于超低延迟的 TCP/UDP 流量。
经典负载均衡器 (CLB)：同时支持第4层和第7层，但现在大多已被 ALB 和 NLB 取代。

负载均衡器提高了容错能力、可扩展性并确保了高可用性。

35. 你用过 Auto Scaling Groups (ASG) 吗？

是的，我曾使用 ASGs 根据需求自动调整实例数量。

ASGs 配置了根据 CPU 使用率等指标调整所需容量的策略，有助于维持应用性能并优化成本。

36. 你能写一个简单的 Dockerfile 吗？

是的，这里有一个用于 Node.js 应用的简单 Dockerfile 示例：

FROM node:14
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD [ "npm", "start" ]

37. 如果你想将你的应用暴露给公共互联网，或者在集群内部访问你的应用，在 Kubernetes 中你会怎么做？

要将你的应用暴露给公共互联网，你可以使用类型为 LoadBalancer 或 NodePort 的 Kubernetes Service。

对于集群内部访问，你可以使用 ClusterIP 服务。此外，你可能还需要使用 Ingress 控制器来实现更高级的路由。

38. 为什么我们在 Kubernetes 中需要 ConfigMap？

ConfigMap 用于以键值对的形式存储非机密的配置数据。

它允许你将配置工件与镜像内容解耦，使你无需重建容器镜像即可修改应用设置。

39. 在为微服务应用设置 CI/CD 流水线时，你会考虑哪些 AWS 服务？

对于 CI/CD 流水线，我会考虑使用：

AWS CodeCommit 进行源代码控制。

AWS CodeBuild 进行构建和测试。

AWS CodeDeploy 或 Amazon EKS 进行部署。

AWS CodePipeline 来编排 CI/CD 过程。

Amazon S3 用于工件存储。

AWS Lambda 用于任何自定义自动化任务。

40. 在一个电商应用流量异常高的日子，作为云工程师，你将如何管理当前设置以平稳处理负载？

我将确保 Auto Scaling Groups 配置正确，以通过自动添加更多实例来处理增加的需求。

我还将验证负载均衡器是否均匀分配流量，并考虑启用缓存（例如使用 Amazon CloudFront）以减少后端服务器的负载。将使用 CloudWatch 等监控工具来跟踪性能指标并实时调整资

策略：

自动扩缩容：自动扩展实例以处理增加的负载。
缓存：使用缓存层来减少应用服务器的负载。 *** 负载均衡**：在可用实例间均匀分配流量。
数据库优化：确保数据库配置正确并针对性能进行优化。
监控：密切监控系统指标以识别瓶颈并相应调整资源。

41. 如果流量当前由单个实例处理，你将如何在 AWS 中进行高可用性升级？

为了进行高可用性升级，我将：

部署多个实例到不同的可用区 (AZs)，使用 Auto Scaling Group。
设置负载均衡器 (ALB 或 NLB) 在这些实例间分配流量。
配置健康检查 以确保流量只路由到健康的实例。
对数据库（如 RDS）使用多可用区部署以确保数据可用性。

42. 在自动扩缩容实例时，你如何管理后端 RDS 数据库？

在自动扩缩容期间管理后端 RDS 数据库：

启用多可用区 以实现高可用性和自动故障转移。

使用 RDS 只读副本来处理读取密集型流量，减少主数据库的负载。

根据数据库工作负载垂直扩展（实例大小）或水平扩展（只读副本）RDS。

使用 Amazon CloudWatch 监控性能，并根据需要进行调整。

43. 你曾经为 S3 设置过跨账户访问吗？例如，如果 QA 团队需要访问生产数据库。

是的，我通过以下方式设置过跨账户访问：

在生产账户中创建一个具有必要 S3 权限的 IAM 角色。

建立信任关系，允许 QA 账户担任该角色。

使用 S3 桶策略 授予 QA 账户访问权限。

QA 团队成员随后可以使用 AWS STS（安全令牌服务）来担任该角色，以访问生产 S3 桶。

44. 账户 A 中的 S3 如何访问账户 B 中的 S3 账户？

账户 A 可以通过以下方式访问账户 B 的 S3 桶：

在账户 B 中设置桶策略，授予账户 A 必要的权限。

在账户 B 中创建一个 IAM 角色，该角色具有 S3 权限，并允许账户 A 通过信任策略担任该角色。

使用 AWS STS 从账户 A 担任该角色，以访问账户 B 中的 S3 桶。

45. 你能区分 IAM 策略和 IAM 角色吗？

IAM 策略：这些是附加到用户、组或角色的权限集合，定义了允许或拒绝哪些操作。

IAM 角色：这些是具有特定权限的身份，可以被实体（如用户、应用或 AWS 服务）担任。角色通常用于临时访问或跨账户访问。

46. 你能解释一下 STS 担任角色策略吗？

STS（安全令牌服务）担任角色策略允许用户或服务在不同账户或同一账户内担任一个角色。

这提供了与所担任角色关联的临时安全凭据，从而实现跨账户访问或权限委派。

47. 你在项目中是否遇到过任何具有挑战性的问题或事件？你和你的团队是如何识别和解决它们的？

是的，一个挑战是流量突然激增导致性能下降。

我们使用 CloudWatch 指标和日志识别了问题，找到了数据库中的瓶颈。

解决方案包括垂直扩展数据库并添加只读副本来分散负载，同时优化运行缓慢的查询。

48. Docker 中 CMD 和 ENTRYPOINT 有什么区别？

CMD：为入口点或要运行的命令提供默认参数，如果没有提供其他命令的话。

ENTRYPOINT：定义将始终运行的可执行文件，CMD 作为其默认参数。当你希望容器表现得像一个特定的可执行文件时，ENTRYPOINT 很有用。

示例：ENTRYPOINT ["python", "app.py"]确保 app.py 始终被执行，而 CMD 允许传递不同的参数。

49. 你曾经独立管理过应用吗？

是的，我曾独立管理过应用，处理诸如部署、监控、故障排除和扩缩容等任务。

这涉及设置基础设施、CI/CD 流水线，并确保高可用性和安全性

50. 基础设施即代码 (IaC) 有什么好处？

一致性：通过自动化配置过程确保环境一致。

版本控制：基础设施可以被版本化和跟踪，支持回滚和审计。

自动化：减少人工干预，最大限度地减少错误并加快部署速度。

可扩展性：允许通过脚本轻松扩展和管理资源。

协作：团队可以使用代码审查和版本控制系统更有效地协作。

51. 创建基础设施即代码有哪些不同的方法？

Terraform：一个流行的开源工具，允许你使用声明式配置语言定义基础设施即代码。它可与各种云提供商协作。

AWS CloudFormation：AWS 提供的一项服务，使你能够使用 JSON 或 YAML 模板定义 AWS 资源。

Azure Resource Manager (ARM) 模板：Azure 的基础设施即代码解决方案，允许你用 JSON 定义资源。

Google Cloud Deployment Manager：Google 的基础设施即代码工具，使用 YAML 定义资源。

Ansible：虽然主要是配置管理工具，但也可以使用 YAML 编写的 playbook 来配置基础设施。

Pulumi：一个现代化的基础设施即代码工具，支持多种编程语言，如 Python、JavaScript 和 Go

52. 公共网络和私有网络之间有什么区别？

公共网络：指可从互联网访问的网络。使用公共 IP 地址，资源对外部访问是暴露的。

私有网络：指与公共互联网隔离的网络。

私有网络内的资源使用私有 IP 地址进行安全通信，外部访问通常受到限制。

53. 什么是 Docker 仓库，为什么我们需要它？

Docker 仓库：一个用于 Docker 镜像的存储和分发系统。它允许你存储、共享和管理 Docker 容器镜像。Docker Hub 是一个流行的公共仓库，但你也可以设置私有仓库。

为什么我们需要它：Docker 仓库使团队能够轻松地对 Docker 镜像进行版本控制、共享和部署。它们通过支持自动构建和部署来支持 CI/CD 流水线。

54. 什么是 Secrets Manager？

Secrets Manager：一个安全存储和管理敏感信息的工具或服务，例如 API 密钥、密码、证书和令牌。示例包括 AWS Secrets Manager、HashiCorp Vault 和 Azure Key Vault。

目的：在不将密钥硬编码到应用代码或配置文件中的情况下安全地存储和访问它们。

55. 管理敏感信息的安全方法是什么？

使用 Secrets Manager：将密钥存储在专用服务中，如 AWS Secrets Manager、Azure Key Vault 或 HashiCorp Vault。

环境变量：使用环境变量在运行时注入密钥，而不是将其存储在代码中。

加密存储：将敏感数据存储在加密的数据库或文件中，确保密钥被安全管理。

访问控制：实施严格的访问控制和审计，确保只有授权的人员和应用可以访问敏感信息

56. 你用过 Kubernetes (K8s) 吗？

如果你有 Kubernetes 经验，可以讨论：

使用 Kubernetes 部署和管理容器化应用。
配置 Kubernetes 集群和使用 kubectl 等工具。
在 Kubernetes 中管理服务、Ingress 和网络。
使用 Helm charts 打包和部署应用。

57. Docker 和 Kubernetes 有什么区别？

Docker：一个用于在容器内开发、交付和运行应用的平台。它简化了管理应用依赖项和环境一致性的过程。

Kubernetes：一个用于自动化容器化应用的部署、扩展和管理的开源编排系统。Kubernetes 管理跨集群的多个容器，提供负载均衡、扩展和自我修复等功能。

58. 你能解释一下应用的端到端部署过程吗？

端到端部署过程可能涉及以下步骤：

代码提交：开发人员将代码更改推送到像 Git 这样的版本控制系统。
CI/CD 流水线：持续集成流水线构建代码，运行测试并创建 Docker 镜像。
镜像存储：Docker 镜像被推送到 Docker 仓库。
部署：镜像被 Kubernetes、Docker Swarm 或其他编排工具从仓库拉取，并部署到暂存或生产环境。
监控与日志：监控应用的性能和错误，收集并分析日志。
扩展与更新：根据需求扩展应用，并使用蓝绿部署或金丝雀部署等策略推出更新。

59. 如果你想使用 Kubernetes 而不是 EC2 实例，你会怎么做？你用过 Helm charts 或其他 CD 工具吗？你如何处理 Kubernetes 上具有多个微服务的项目

使用 Kubernetes 替代 EC2：你将在 Kubernetes 集群上部署你的应用，而不是直接在 EC2 实例上。这涉及在 AWS 中设置 EKS（弹性 Kubernetes 服务）集群或使用其他托管的 Kubernetes 服务。

Helm Charts：Helm 是 Kubernetes 的包管理器，可帮助你管理 Kubernetes 应用。你可以使用 Helm charts 以一致且可重复的方式部署和管理多个微服务。

处理多个微服务：使用 Kubernetes 命名空间来隔离微服务，并使用 Helm charts 或像 Jenkins、ArgoCD 或 GitLab CI/CD 这样的 CI/CD 工具来管理它们的部署。实施服务发现、网络和安全策略，以确保微服务之间的无缝通信。

60. 你如何将堡垒主机连接到私有网络？你能解释一下 VPC 和 VPC 对等连接吗？

连接堡垒主机：堡垒主机通常设置在虚拟私有云 (VPC) 的公共子网中，并可以访问私有网络。

用户通过 SSH 连接到堡垒主机，然后从那里可以访问私有子网中的资源。

VPC（虚拟私有云）：云提供商网络中的一个逻辑隔离部分，你可以在其中启动和管理资源。它允许你定义 IP 范围、子网、路由表和网络网关。

VPC 对等连接：两个 VPC 之间的网络连接，允许使用私有 IP 地址在它们之间路由流量。这对于在不通过公共互联网的情况下连接不同 VPC 之间的资源很有用。

61. 你是否配置过一个系统，在开发者完成 Jira 中的票后，代码会自动合并和发布？你具体管理了什么？

是的，我设置过一个 CI/CD 流水线，当开发者完成 Jira 中的票时，代码会自动合并和发布。这个过程通常包括：

与 Jira 集成：配置 Jira 在票被标记为“完成”或移动到特定工作流阶段时触发 CI/CD 流水线。

代码合并：使用 GitLab CI、GitHub Actions 或 Jenkins 等工具在测试通过后自动将功能分支合并到主分支。

自动化测试：运行单元测试、集成测试和端到端测试，以确保代码质量，然后进行合并。

部署：使用部署工具，如 Kubernetes、Helm 或 Docker Swarm，自动将合并后的代码部署到暂存或生产环境。

62. 你如何在服务器上设置 Nginx？

在服务器上设置 Nginx 涉及：

安装：

对于 Ubuntu/Debian：sudo apt-get update && sudo apt-get install nginx

对于 CentOS/RHEL：sudo yum install nginx

配置：

编辑位于 /etc/nginx/nginx.conf的配置文件或 /etc/nginx/sites-available/中的各个站点配置。

定义 server blocks（虚拟主机）以指定不同的站点及其根目录。
根据需要配置反向代理、负载均衡、SSL/TLS 证书和缓存。
启动并启用 Nginx：

启动服务：sudo systemctl start nginx

启用开机启动：sudo systemctl enable nginx

测试：

测试配置：sudo nginx -t

确保 Nginx 正在运行并正确提供内容。

63. 什么是负载均衡器及其好处？什么是 Cloud NAT？

负载均衡器：负载均衡器将传入的网络流量分配到多台服务器或服务，以确保可靠性、可扩展性和高可用性。好处包括：

提高容错能力：分配流量以防止单个服务器过载。

可扩展性：通过添加更多服务器轻松管理增加的流量。

提高性能：根据性能指标平衡负载，减少延迟。

Cloud NAT：像 Google Cloud 这样的云环境中的网络地址转换 (NAT) 服务。

它允许私有子网中的实例连接到互联网，而不将它们暴露给入站互联网流量，在保持安全的同时实现出站连接。

64. 负载均衡器和 Cloud NAT 网关有什么区别？

负载均衡器：

将传入流量分配到多台服务器或服务。
主要用于负载分配、冗余和高可用性。
在不同层（TCP 用 L4，HTTP/HTTPS 用 L7）工作。

Cloud NAT 网关：

为私有网络中的实例提供出站互联网访问，而不将其暴露给入站流量。
用于需要互联网访问但不希望直接从互联网访问的安全私有实例。

65. 你如何看待自己适合这个特定职位？

我认为自己适合这个职位，因为我拥有基础设施管理、自动化和云技术方面的专业知识。

我在设置 CI/CD 流水线、管理部署和优化资源分配方面的经验与该职位的职责相符。我还带来了解决问题的技能和积极主动的方法来确保系统可靠性，这将有助于团队和组织的成功。

66. 你采取了哪些成本优化措施来减少云支出？结果如何？

在一个之前的项目中，我注意到我们的云基础设施存在过度配置，导致不必要的成本。

我根据实际使用指标实施了自动扩缩容，并对非关键工作负载利用了 Spot 实例。

此外，我通过将不经常访问的数据移动到成本更低的存储类别来重构存储解决方案。

这些变化使我们的月度云支出显著减少，且未影响性能。

67. 描述一个整个生产实例崩溃，你必须快速修复的情况。你经历过这种情况吗？

是的，我经历过这种情况。有一次，由于应用中的内存泄漏，我们的生产服务器崩溃了。

我使用像 Prometheus 这样的监控工具和 ELK Stack 的日志快速识别了问题。

为了解决它，我重启了受影响的服务，并临时扩展了基础设施以处理负载。然后我与开发团队合作，识别并修复了内存泄漏，确保不再发生。

68. 什么是蓝绿部署，为什么需要它？

蓝绿部署：

一种部署策略，其中维护两个相同的环境（蓝色和绿色）。
蓝色环境是活跃的生产环境，而绿色是闲置的。在部署期间，新版本被部署到绿色环境。
经过测试后，流量切换到绿色，使其成为新的生产环境。

为什么需要：

最小化停机时间：由于环境之间的切换是即时的，减少了停机时间。

易于回滚：如果出现问题，切换回蓝色环境很简单。

提高可靠性：降低了部署失败影响用户的风险。

69. 你还知道哪些其他部署策略？

金丝雀部署：在全面部署之前，将新版本逐步推送给一小部分用户。

滚动部署：使用新版本逐步更新实例或服务器，确保至少有一些实例始终运行旧版本。

A/B 测试：类似于蓝绿部署，但用于通过实时用户流量比较不同版本/功能，以确定哪个表现更好。

功能开关：允许动态开启/关闭功能，使得部署不完整的功能而不会影响用户。

70. 你用过哪些高级的 AWS 资源类型？

AWS Lambda：无服务器计算，用于响应事件运行代码而无需管理服务器。

AWS Fargate：容器的无服务器计算引擎，允许部署容器化应用而无需管理底层基础设施。

Amazon RDS：用于关系数据库的托管数据库服务，包括自动备份、扩展和多可用区部署等功能。

AWS CloudFormation：用于自动化资源配置和管理的基础设施即代码 (IaC) 工具。

Amazon VPC 对等连接和 Transit Gateway：用于创建跨多个 VPC 和账户的复杂网络架构。

AWS Step Functions：用于将 AWS Lambda 函数和其他服务组合成无服务器工作流的编排服务。

71. 在 DevOps 工程师的帮助下，托管模块（如 AI/ML）如何在 AWS 中根据不同的前端/后端需求进行部署、定制和扩展？

在 AWS 中部署、定制和扩展托管模块

部署：DevOps 工程师使用像 AWS CodePipeline 这样的工具来自动化托管 AI/ML 模块的部署。这涉及：

容器化：将模块打包到 Docker 容器中以实现可移植性。
基础设施配置：使用 IaC（例如 CloudFormation）来设置必要的 AWS 资源（EC2 实例、S3 桶等）。
部署自动化：使用像 AWS CodeDeploy 这样的工具将容器部署到已配置的基础设施上。

定制：定制通常涉及：

配置管理：使用像 Ansible 或 Puppet 这样的工具根据特定需求配置模块。
环境变量：使用环境变量为不同环境（开发、测试、生产）注入不同的配置。

扩展：DevOps 工程师利用以下 AWS 服务：

Auto Scaling Groups：根据负载自动调整实例数量。
Elastic Load Balancing：在多个实例间分配流量以实现高可用性。
无服务器计算：使用像 AWS Lambda 这样的服务来动态扩展 AI/ML 工作负载

72. 你能描述一下一个你以前没听说过但通过自学掌握并使用的技术吗？

学习一项新技术

示例：我最近学习了 Apache Kafka，一个分布式流处理平台。我最初不熟悉其概念，但对其实时数据处理的潜力很感兴趣。

学习过程：我从阅读文档、观看教程和自行尝试使用 Kafka 开始。我还加入了在线社区和论坛，与其他用户联系并从他们的经验中学习。

应用：我成功地在项目中实现了 Kafka 来处理高容量事件流，提高了数据处理效率和实时洞察力。

73. 你作为 DevOps 工程师面临过哪些挑战？

复杂性：管理具有多个服务和依赖项的复杂云环境。

自动化：在自动化和人工干预之间找到适当的平衡。

安全性：确保云基础设施和应用程序的安全。

协作：与开发人员、运维团队和其他利益相关者有效合作。

持续学习：跟上云计算领域的快速变化步伐。

76. 在发生数据丢失时，你使用什么策略来确保没有数据丢失，特别是在像银行这样的关键应用中？

数据丢失预防策略

策略：对于像银行这样的关键应用，采用多层次的方法是必要的：
冗余：使用多个数据中心或云区域进行复制和故障转移。
备份：实施频繁且自动化的备份到多个位置。
版本控制：跟踪数据更改并维护历史版本。
监控：监控数据库健康状况和性能以尽早发现潜在问题。
灾难恢复计划：制定全面的灾难恢复计划，以便在发生中断时恢复数据和服务

77. 你是否遇到过针对你构建和实施的系统的网络攻击？你采取了哪些预防措施？

网络攻击与预防措施

经验：我曾遇到过安全事件，如暴力攻击和试图利用漏洞的行为。

预防措施：

安全最佳实践：实施强密码、多因素认证和最小权限访问。

漏洞扫描：定期扫描系统漏洞并及时修补。

安全监控：使用安全信息和事件管理 (SIEM) 工具来监控可疑活动。

事件响应计划：制定计划以有效响应安全事件。

78. 你遵循哪些网络设置规则？

网络设置规则

规则：

安全组：使用安全组来控制进出实例的流量。
网络分段：将网络分成更小的段以隔离资源并限制安全漏洞的影响。
防火墙规则：实施防火墙规则以阻止未经授权的访问。
VPN 和隧道：使用 VPN 和隧道来保护网络之间的通信。
网络监控：监控网络流量和性能以识别潜在问题。

79. 作为一名 DevOps 工程师，你的日常职责是什么？

日常职责

监控：监控系统健康、性能和安全性。
自动化：自动化部署、基础设施配置和备份等任务。
故障排除：解决问题和事件。
协作：与开发人员、运维团队和其他利益相关者合作。
持续改进：识别改进领域并实施更改以提高效率和可靠性。

80. 你精通哪些 DevOps 工具？

DevOps 工具熟练度

基础设施即代码：Terraform, CloudFormation, Ansible, Puppet。

容器化：Docker, Kubernetes。

CI/CD：Jenkins, GitLab CI/CD, AWS CodePipeline。

监控与日志：Prometheus, Grafana, ELK Stack。

配置管理：Ansible, Puppet, Chef。

版本控制：Git。

81. 你能描述一下你项目中的 CI/CD 工作流程吗？

CI/CD 工作流程描述

示例：在最近的一个项目中，我们的 CI/CD 工作流程包括：

代码提交：开发人员将代码更改提交到 Git 仓库。
构建和测试：一个 CI 服务器（如 Jenkins, GitLab CI）自动构建应用程序，运行单元测试并执行代码质量检查。
工件存储：成功的构建作为工件存储在仓库（如 S3）中。
部署：CD 服务器（如 AWS CodeDeploy）将工件部署到目标环境（开发、测试、生产）。
监控：持续监控工具（如 Prometheus, Grafana）跟踪应用健康状况和性能。

82. 在你的项目中，你如何处理持续交付 (CD) 方面？

持续交付 (CD) 处理

方法：

自动化部署：使用像 AWS CodeDeploy 这样的工具将部署自动化到不同的环境。

蓝绿部署：将新版本的应用与现有版本一起部署，允许无缝切换。

金丝雀部署：逐步向一小部分用户推出新版本，在全面部署前监控问题。

功能开关：使用功能开关来启用或禁用应用中的功能而无需更改代码，允许受控发布。

83. 你用什么方法来检查代码漏洞？

代码漏洞检查方法

静态代码分析：使用 SonarQube 或 Snyk 等工具分析代码中的漏洞和安全问题。

动态代码分析：使用 Burp Suite 或 ZAP 等工具在运行时测试应用程序的漏洞。

安全扫描：使用 AWS Inspector 或 Qualys 等工具扫描基础设施和应用程序的漏洞。

84. 你精通哪些 AWS 服务？

AWS 服务熟练度

服务：

计算：EC2, Lambda, ECS, EKS。

存储：S3, EBS, EFS。

网络：VPC, Route 53, Load Balancers。

数据库：RDS, DynamoDB, Redshift。

CI/CD：CodePipeline, CodeBuild, CodeDeploy。

安全：IAM, Security Groups, KMS。

监控：CloudWatch。

85. 如果你的应用运行在账户 B 的 EC2 实例上，你如何访问账户 A 的 S3 桶中的数据？

从账户 B 访问 S3

方法：使用 IAM 角色和跨账户权限：

创建角色：在账户 A 中创建一个具有访问 S3 桶权限的 IAM 角色。
担任角色：在账户 B 中，配置 EC2 实例以担任在账户 A 中创建的角色。
访问 S3：EC2 实例现在可以使用担任角色的凭据访问 S3 桶。

86. 你如何提供对 S3 桶的访问，需要在桶端设置哪些权限？

S3 桶访问和权限

访问：你可以通过以下方式提供对 S3 桶的访问：

IAM 策略：向用户、组或角色附加策略以授予特定权限。
桶策略：直接在桶上定义访问控制规则。

权限：常见权限包括：

读取：允许用户从桶中读取对象。
写入：允许用户向桶中写入对象。
删除：允许用户从桶中删除对象。
列出：允许用户列出桶中的对象。

87. 具有静态 IP 的实例 2 如何与位于私有子网并映射到多可用区负载均衡器的实例 1 通信？

与私有子网中的实例通信

方法：使用 NAT 网关或堡垒主机。

NAT 网关：一个托管服务，为私有子网中的实例提供互联网访问。
堡垒主机：公共子网中的一个安全服务器，允许访问私有实例。

88. 对于私有子网中的 EC2 实例，如果不使用 NAT 网关或堡垒主机，它如何验证并从互联网下载所需的软件包？是否有其他 AWS 服务可以促进这一点？

私有子网中的 EC2 实例访问互联网

方法：使用私有 DNS 主机名：

私有 DNS：在你的 VPC 内配置一个私有 DNS 区域。
私有主机名：为 EC2 实例分配一个私有主机名。
DNS 解析：EC2 实例可以解析私有主机名以访问互联网资源。

89. 负载均衡器的典型延迟是多少？如果遇到高延迟，你会采取哪些监控步骤？

负载均衡器延迟和监控

典型延迟：负载均衡器延迟通常从几毫秒到几百毫秒不等，具体取决于网络状况和负载等因素。

监控步骤：

CloudWatch 指标：使用 CloudWatch 指标监控负载均衡器延迟。

网络跟踪：使用像 AWS X-Ray 这样的工具跟踪通过负载均衡器的请求并识别瓶颈。

性能测试：运行负载测试以模拟真实流量并识别性能问题。

90. 如果你的应用托管在 S3 上，而用户位于不同的地理位置，你如何减少延迟？

为 S3 托管的应用减少延迟

方法：

边缘站点：使用 AWS CloudFront 将内容缓存在离用户更近的边缘站点，减少延迟。
区域桶：在与用户相同的区域存储数据在 S3 桶中，减少网络跳数。
内容分发网络 (CDNs)：使用 CDN 在全球多个位置分发内容，减少全球用户的延迟。
哪些服务可以与 CDN（内容分发网络）集成？

91. 哪些服务可以与 CDN（内容分发网络）集成？

CDN 集成

服务：CDN 可以与各种服务集成，包括：

Web 服务器：Apache, Nginx, IIS。
内容管理系统 (CMS)：WordPress, Drupal, Joomla。
云存储：AWS S3, Google Cloud Storage, Azure Blob Storage。
流媒体服务：Netflix, YouTube, Twitch。
API 网关：AWS API Gateway, Google Cloud Endpoints。

92. 你如何动态地从 AWS 检索 VPC 详细信息以使用 IaC 创建 EC2 实例？

动态检索 VPC 详细信息

方法：使用 Terraform 的数据源：

aws_vpc 数据源：通过其 ID 或名称检索特定 VPC 的详细信息。
aws_subnet 数据源：检索 VPC 中子网的详细信息。
aws_security_group 数据源：检索与 VPC 关联的安全组的详细信息。
aws_instance 数据源：检索 VPC 内现有 EC2 实例的详细信息。

93. 在 Terraform 中管理非托管资源

方法：使用 terraform import 命令将现有的非托管资源纳入 Terraform 的控制。这允许你将它们与你的 IaC 代码一起管理。

94. 在导入 VPC 时传递参数

方法：使用 terraform import 命令的 --var 标志传递参数：

terraform import aws_vpc.example "vpc-1234567890abcdef0" --var="cidr_block=10.0.0.0/16"

95. Jenkins 中的主从架构是什么？

Jenkins 中的主从架构允许你将构建任务分布到多个节点（从节点）。这提供了：

并行执行：在多个节点上并发运行构建，减少构建时间。

资源优化：为不同的构建任务利用不同的硬件配置。

可扩展性：通过添加更多从节点来扩展 Jenkins 基础设施。

96. 你如何将 LDAP 与 AWS 和 Jenkins 集成？

你可以通过以下方式将 LDAP 与 AWS 和 Jenkins 集成：

配置 LDAP：设置 LDAP 服务器并配置其以进行用户身份验证。
AWS IAM：创建一个具有访问 LDAP 服务器权限的 IAM 角色。
Jenkins 配置：配置 Jenkins 以使用 LDAP 服务器进行身份验证。

97. GitHub 的一些主要功能是什么？

版本控制：随时间跟踪代码更改。
协作：促进开发人员之间的协作。
Pull Requests：支持代码审查和批准。
Issues：跟踪错误、功能请求和其他任务。
Projects：组织和管理工作项。

98. Jenkins 的一些主要功能是什么？

持续集成 (CI)：自动化构建、测试和部署过程。
持续交付 (CD)：将应用程序部署到不同环境。
流水线即代码：使用代码（Jenkinsfile）定义流水线。
插件：通过广泛的插件扩展 Jenkins 功能。
主从架构：将构建任务分布到多个节点。

99. CI/CD 的好处和用途是什么？

更快交付：减少交付新功能和更新的时间。
提高质量：在开发过程中尽早发现错误和问题。
提高效率：自动化重复性任务，让开发人员专注于创新。
降低风险：更频繁、更低风险地部署更改。

CI/CD 的用途：

软件开发：自动化构建、测试和部署过程。
基础设施管理：自动配置和配置基础设施。
数据流水线：自动化数据处理和分析任务。

100. 什么是 GitHub 工作流，它是如何使用的？

GitHub 工作流是一组自动化任务，由 GitHub 仓库中的事件触发。

你可以使用工作流来：

构建和测试代码：自动化构建和测试过程。
部署应用程序：将应用程序部署到不同环境。
运行代码分析：执行代码质量检查和安全扫描。

101. 你如何处理 Git 中的合并冲突？

识别冲突：Git 在合并分支时会识别冲突。

解决冲突：通过编辑受影响的文件手动解决冲突。

暂存更改：使用 git add 暂存已解决的文件。

提交更改：使用 git commit 并附带描述性消息提交更改。

102. 当 Jenkins 中的构建失败时，你采取哪些步骤？

当 Jenkins 中的构建失败时，你应该：

分析日志：查看构建日志以确定失败原因。
故障排除：调查问题并尝试解决。
修复代码：如果失败是由于代码错误，修复代码并重新构建。
更新配置：如果失败是由于配置问题，更新 Jenkins 配置。
回滚：如有必要，回滚到之前的工作版本。

103. 你如何在 AWS 中执行作业？

你可以在 AWS 中使用以下方式执行作业：

AWS Batch：一个完全托管的批处理计算服务，用于运行大规模、计算密集型作业。

AWS Lambda：一个无服务器计算服务，用于响应事件运行代码。

AWS ECS：一个容器编排服务，用于部署和管理容器化应用。

104. 什么是 Ansible 角色，你如何使用它们？

Ansible 角色是组织和重用 Ansible playbooks 的一种方式。

它们封装了与特定组件或服务相关的任务、变量和依赖项。你使用角色来：

模块化 Playbooks：将复杂的 playbooks 分解为更小的、可重用的单元。
简化部署：使用单个角色部署多个组件或服务。
提高可维护性：使管理和更新 Ansible 配置更容易。

105. 你如何通过 Docker 卷确保数据持久性？

使用 Docker 卷将数据持久化在容器外部：

命名卷：创建可以在容器之间共享的命名卷。
数据卷：将数据卷从主机机器挂载到容器中。
绑定挂载：将目录从主机机器挂载到容器中。

106. Docker 和 Kubernetes 之间的主要区别是什么？

范围：Docker 专注于容器化，而 Kubernetes 专注于容器编排。

管理：Docker 管理单个容器，而 Kubernetes 管理容器集群。

可扩展性：Kubernetes 提供了用于扩展和管理大规模部署的高级功能。

网络：Kubernetes 为容器通信提供了更复杂的网络功能。

107. 你如何在 GitHub 中安全地存储凭据？

你可以使用以下方式在 GitHub 中安全地存储凭据：

GitHub Secrets：使用 GitHub Secrets 安全地存储敏感信息。
环境变量：在你的 GitHub 工作流中设置环境变量以访问凭据。
GitHub Actions：使用 GitHub Actions 管理凭据并在你的工作流中访问它们。

108. Jenkinsfile 通常存储在哪里？

Jenkinsfile 通常存储在你的 Git 仓库的根目录中。

109. 你如何在 Python 脚本中执行 shell 脚本？

使用 subprocess 模块：

import subprocess
subprocess.run(["/path/to/script.sh"])

110. 你如何与 Jenkins 服务器和 Kubernetes 集群通信？

你可以使用以下方式与 Jenkins 服务器和 Kubernetes 集群通信：

Jenkins 插件：使用像 Kubernetes 插件这样的 Jenkins 插件来与 Kubernetes 集群交互。

API 调用：使用 Kubernetes API 以编程方式与集群交互。

kubectl：从 Jenkins 内部使用 kubectl 命令来管理 Kubernetes 资源。

111. 在 Kubernetes 中，你只更新 Docker 镜像吗？还是也更新副本数量、存储级别和 CPU 分配？

你可以更新各种 Kubernetes 资源，包括：

Docker 镜像：更新部署所使用的容器镜像。
副本数量：向上或向下扩展部署的副本数量。
存储级别：调整持久卷的存储容量。
CPU 分配：修改容器的 CPU 和内存资源请求和限制。

112. 你可以在 Jenkins 流水线中定义环境变量吗？

是的，你可以在 Jenkins 流水线中定义环境变量，使用：

流水线脚本：在你的 Jenkinsfile 中使用 environment 指令来定义环境变量。
全局变量：在 Jenkins 设置中配置全局环境变量。
凭据：将敏感信息存储为凭据并在流水线内访问它们。

113. 工件在 Jenkins 中的作用是什么，为什么我们需要将它们推送到 Nexus 而不是在本地构建和存储它们？

工件是构建过程的输出，例如编译的代码、容器镜像或测试报告。将工件推送到 Nexus（一个仓库管理器）提供了：

版本控制：跟踪不同版本的工件。
依赖管理：管理项目之间的依赖关系。
安全性：控制对工件的访问并确保其完整性。

114. 如果你正在开发一个基于 Python 的应用，你如何分离本地部署所需的包，以避免干扰全局安装的包？

使用虚拟环境：

创建虚拟环境：使用 python -m venv <环境名称> 创建一个虚拟环境。

激活环境：使用 source <环境名称>/bin/activate 激活环境。

安装包：使用 pip install <包名> 安装特定于项目的包。

115. 在 Terraform 中导入 VPC 之前有哪些先决条件？

在导入 VPC 之前，你需要：

Terraform 配置：一个 Terraform 配置文件，定义了你想要导入的 VPC 资源。

资源 ID：VPC 在 AWS 中的唯一标识符 (ID)。

资源类型：正确的 Terraform 资源类型（例如，aws_vpc）。

116. 如果一个 S3 桶是通过 Terraform 创建的，但有人手动为其添加了策略，你如何使用 IaC 处理这种情况？

你可以使用 Terraform 的 terraform plan 命令来检测 S3 桶当前状态与你的 IaC 配置之间的差异。这将突出显示手动添加的策略。然后你可以：

更新 IaC：修改你的 Terraform 配置以包含手动添加的策略，确保一致性。

忽略：如果策略是可接受的，使用 Terraform 中的 ignore_changes 选项将其从未来的计划中排除。 [文件内容结束]