超级会员免费看
微服务安全与配置管理实践
1. 服务请求状态分析
在服务请求过程中，不同的状态码能反映出不同的问题。当我们向消息服务发送请求时，若得到 404 状态码，这表明请求已成功到达该服务，但所请求的资源未找到。例如：
{
"timestamp": 1532318740403,
"status": 404,
"error": "Not Found",
"exception": "com.packtpub.microservices.ch06.message.exceptions.MessageNotFoundException",
"message": "Message 123 could not be found",
"path": "/123"
}
若我们修改请求头中的 JWT（JSON Web Token），则会得到 401 状态码，意味着请求未被授权。示例命令如下：
$ curl -D - -H "Authorization: Bearer not-the-right-jwt" http://localhost:8080/messages/123
返回结果：
{
"timestamp": 1532318807874,
"status": 401,
"error": "Unauthorized",
"message": "No message available",
"path": "/messages/123"
}
2. 容器安全
容器的出现为管理微服务架构的组织解决了许多问题。它允许将服务打包成自包含的单元，软件及其依赖项可构建为单个工件，然后部署到任何环境中运行或调度。同时，容器支持不可变基础设施的理念，即基础设施一旦构建完成，无需升级或维护，只需构建新的基础设施并丢弃旧的。
然而，多租户环境下，多个服务在同一虚拟机上运行会引入新的攻击场景。攻击者若能利用一个服务的漏洞，可能会攻击同一虚拟机上的其他服务。默认情况下，集群被视为安全边界，但这可能无法满足某些组织的需求，因此需要更多的安全和隔离措施。
seccomp 安全机制在 Linux 内核 2.6.12 版本中引入，它支持限制进程可进行的系统调用。使用 seccomp 策略运行容器化应用程序，可对服务和容器内的其他进程进行沙箱化处理。以下是使用 seccomp 策略的操作步骤：
1. 检查 Linux 内核是否支持 seccomp ：
bash $ grep CONFIG_SECCOMP= /boot/config-$(uname -r)
若输出 CONFIG_SECCOMP=y ，则表示 seccomp 已启用。
2. 查看 Docker 自带的默认配置文件 ：可查看 https://github.com/moby/moby/blob/master/profiles/seccomp/default.json ，该默认策略能满足大多数需求且限制较为严格。
3. 创建自定义策略并验证 ：
创建 policy.json 文件，内容如下：
json { "defaultAction": "SCMP_ACT_ALLOW", "syscalls": [ { "name": "chown", "action": "SCMP_ACT_ERRNO" } ] }
运行容器并执行操作：
bash $ docker run --rm -it --security-opt seccomp:policy.json busybox /bin/sh / # touch foo / # chown root foo chown: foo: Operation not permitted
错误信息表明容器受到 seccomp 策略的限制。
3. 安全配置
服务通常需要某种形式的配置，配置信息会根据服务部署的环境而变化。例如，在开发环境中，服务可能连接本地数据库；而在生产环境中，则应连接生产数据库。常见的配置数据包括数据存储的位置和凭证、访问令牌、第三方服务的凭证以及操作信息等。
将配置与代码分离很重要，这样在进行配置更改时，无需提交代码更改、创建新构建和单独部署。将配置硬编码在代码中从安全角度来看是不良实践，因为任何有权访问源代码的人都能获取配置信息，尤其是涉及机密信息时。
常见的最佳实践是将配置存储在环境变量中，这适用于非机密配置值，如主机名、超时时间和日志级别等。但环境变量不适合存储机密信息，因为存储在其中的机密信息易被同一容器或进程空间中的其他进程拦截。
对于部署在 Kubernetes 集群上的应用程序，可使用特殊的对象类型 secret 来存储机密信息。不过，Kubernetes 中的 secret 在传输过程中使用主节点上的私钥加密，但在静止状态下以明文形式存储。理想情况下，机密信息应存储为加密值，并仅由明确允许的进程解密。
HashiCorp 积极维护的开源项目 Vault 提供了一个易于使用的系统，用于安全地存储和访问机密信息。除了机密存储外，Vault 还提供访问日志审计、细粒度访问控制和轻松滚动等功能。
以下是创建一个名为 attachment-service 的新服务，并使用 Vault 存储敏感配置数据的步骤：
1. 创建 Java 项目 ：创建一个名为 attachment-service 的新 Java 项目，其 build.gradle 文件内容如下：
groovy group 'com.packtpub.microservices' version '1.0-SNAPSHOT' buildscript { repositories { mavenCentral() } dependencies { classpath group: 'org.springframework.boot', name: 'spring-boot-gradle-plugin', version: '1.5.9.RELEASE' } } apply plugin: 'java' apply plugin: 'org.springframework.boot' apply plugin: 'io.spring.dependency-management' sourceCompatibility = 1.8 repositories { mavenCentral() } dependencies { compile group: 'org.springframework.boot', name: 'spring-boot-starter-web' compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '1.5.9.RELEASE' compile group: 'mysql', name: 'mysql-connector-java' compile group: 'com.amazonaws', name: 'aws-java-sdk-s3', version: '1.11.375' testCompile group: 'junit', name: 'junit', version: '4.12' }
2. 创建服务入口类 ：在 com.packtpub.microservices.ch06.attachment 包下创建 Application 类：
```java
package com.packtpub.microservices.ch06.attachment;
import com.amazonaws.auth.EnvironmentVariableCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
@Bean
public AmazonS3 getS3Client() {
AmazonS3ClientBuilder client = AmazonS3ClientBuilder.standard();
return client.withCredentials(
new EnvironmentVariableCredentialsProvider()).withRegion(Regions.US_WEST_2).build();
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
-
创建实体类 ：在
com.packtpub.microservices.ch06.attachment.models包下创建Attachment类：
```java
package com.packtpub.microservices.ch06.attachment.models;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;@Entity
public class Attachment {
@Id
@GeneratedValue(generator = “uuid”)
@GenericGenerator(name = “uuid”, strategy = “uuid2”)
private String id;
@Column(unique = true)
private String messageId;
private String url;
private String fileName;
private Integer mediaType;public Attachment(String messageId, String url, String fileName, Integer mediaType) { this.messageId = messageId; this.url = url; this.fileName = fileName; this.mediaType = mediaType; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getMessageId() { return messageId; } public void setMessageId(String messageId) { this.messageId = messageId; } public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getFileName() { return fileName; } public void setFileName(String fileName) { this.fileName = fileName; } public Integer getMediaType() { return mediaType; } public void setMediaType(Integer mediaType) { this.mediaType = mediaType; }}
4. **创建数据访问接口**：在 `com.packtpub.microservices.ch06.attachment.data` 包下创建 `AttachmentRepository` 接口：java
package com.packtpub.microservices.ch06.attachment.data;
import com.packtpub.microservices.ch06.attachment.models.Attachment;
import org.springframework.data.repository.CrudRepository;
import java.util.List;public interface AttachmentRepository extends CrudRepository {
public List findByMessageId(String messageId);
}
5. **创建请求模型类**：在 `com.packtpub.microservices.ch06.attachment.models` 包下创建 `AttachmentRequest` 类：java
package com.packtpub.microservices.ch06.attachment.models;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.Map;public class AttachmentRequest {
private String fileName;
private String data;public AttachmentRequest() {} public AttachmentRequest(String fileName, String data) { this.fileName = fileName; this.data = data; } public String getFileName() { return fileName; } public void setFileName(String fileName) { this.fileName = fileName; } public String getData() { return data; } public void setData(String data) { this.data = data; } @JsonProperty("file") private void unpackFileName(Map<String, String> file) { this.fileName = file.get("name"); this.data = file.get("data"); }}
6. **创建异常类**：在 `com.packtpub.microservices.ch06.attachment.exceptions` 包下创建 `AttachmentNotFoundException` 类：java
package com.packtpub.microservices.ch06.attachment.exceptions;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;@ResponseStatus(code = HttpStatus.NOT_FOUND, reason = “No attachment(s) found”)
public class AttachmentNotFoundException extends RuntimeException {}
7. **创建控制器类**：在 `com.packtpub.microservices.ch06.attachment.controllers` 包下创建 `AttachmentController` 类：java
package com.packtpub.microservices.ch06.attachment.controllers;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.model.CannedAccessControlList;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.model.PutObjectRequest;
import com.packtpub.microservices.ch06.attachment.data.AttachmentRepository;
import com.packtpub.microservices.ch06.attachment.exceptions.AttachmentNotFoundException;
import com.packtpub.microservices.ch06.attachment.models.Attachment;
import com.packtpub.microservices.ch06.attachment.models.AttachmentRequest;
import org.apache.commons.codec.binary.Base64;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.List;@RestController
public class AttachmentController {
@Autowired
private AttachmentRepository attachmentRepository;
@Autowired
private AmazonS3 s3Client;
@Value(“${s3.bucket-name}”)
private String bucketName;@RequestMapping(path = "/message/{message_id}/attachments", method = RequestMethod.GET, produces = "application/json") public List<Attachment> getAttachments(@PathVariable("message_id") String messageId) { List<Attachment> attachments = attachmentRepository.findByMessageId(messageId); if (attachments.isEmpty()) { throw new AttachmentNotFoundException(); } return attachments; } @RequestMapping(path = "/message/{message_id}/attachments", method = RequestMethod.POST, produces = "application/json") public Attachment create(@PathVariable("message_id") String messageId, @RequestBody AttachmentRequest request) { byte[] byteArray = Base64.decodeBase64(request.getData()); ObjectMetadata metadata = new ObjectMetadata(); metadata.setContentLength(byteArray.length); metadata.setContentType("image/jpeg"); metadata.setCacheControl("public, max-age=31536000"); InputStream stream = new ByteArrayInputStream(byteArray); String fullyResolved = String.format("%s/%s", messageId, request.getFileName()); s3Client.putObject( new PutObjectRequest(bucketName, fullyResolved, stream, metadata) .withCannedAcl(CannedAccessControlList.PublicRead)); String url = String.format("https://%s.s3.amazonaws.com/%s", bucketName, fullyResolved); Attachment attachment = new Attachment(messageId, url, request.getFileName(), 1); attachmentRepository.save(attachment); return attachment; }}
8. **创建配置文件**：在 `src/main/resources` 目录下创建 `application.yml` 文件：yaml
spring:
jpa.hibernate.ddl-auto: create
datasource.url: ${DATABASE_URL}
datasource.username: ${DATABASE_USERNAME}
datasource.password: ${DATABASE_PASSWORD}
s3:
bucket-name: ${BUCKET_NAME}
```
以上步骤完成了使用环境变量存储敏感信息的 attachment-service 的创建。但这种方式仍存在安全风险，后续我们将修改服务，使其从 Vault 读取 S3 凭证。
下面是创建 attachment-service 的流程图：
graph LR
A[创建 Java 项目] --> B[创建服务入口类]
B --> C[创建实体类]
C --> D[创建数据访问接口]
D --> E[创建请求模型类]
E --> F[创建异常类]
F --> G[创建控制器类]
G --> H[创建配置文件]
4. 集成 Vault 存储敏感配置
虽然使用环境变量存储配置比硬编码更安全，但仍存在敏感信息泄露的风险。接下来，我们将修改 attachment-service 以使用 Vault 安全地存储和读取敏感配置数据。
4.1 安装和配置 Vault
- 安装 Vault ：
- 对于 macOS X 用户，若使用 HomeBrew，可通过以下命令安装：
$ brew install vault
- 其他平台的安装说明可参考 [http://www.vaultproject.io](http://www.vaultproject.io)。
- 启动 Vault 开发模式 ：
$ vault server --dev --dev-root-token-id="00000000-0000-0000-0000-000000000000"
- 启用 kv 密钥引擎 ：
$ vault secrets enable -path=secret/attachment-service
- 写入 AWS 凭证 ：
$ vault write secret/attachment-service attachment.awsAccessKeyId=<access-key> attachment.awsSecretAccessKey=<access-secret>
请将 <access-key> 和 <access-secret> 替换为实际的 AWS 访问密钥 ID 和秘密访问密钥。
4.2 修改项目以集成 Vault
- 添加依赖 ：
在build.gradle文件中添加以下依赖：
compile group: 'org.springframework.cloud', name: 'spring-cloud-starter-vault-config', version: '1.1.1.RELEASE'
完整的 build.gradle 文件如下：
group 'com.packtpub.microservices'
version '1.0-SNAPSHOT'
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath group: 'org.springframework.boot', name: 'spring-boot-gradle-plugin', version: '1.5.9.RELEASE'
}
}
apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
sourceCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
compile group: 'org.springframework.boot', name: 'spring-boot-starter-web'
compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '1.5.9.RELEASE'
compile group: 'org.springframework.cloud', name: 'spring-cloud-starter-vault-config', version: '1.1.1.RELEASE'
compile group: 'mysql', name: 'mysql-connector-java'
compile group: 'com.amazonaws', name: 'aws-java-sdk-s3', version: '1.11.375'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
- 创建配置类 ：
在com.packtpub.microservices.ch06.attachment.config包下创建Configuration类：
package com.packtpub.microservices.ch06.attachment.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("attachment")
public class Configuration {
private String awsAccessKeyId;
private String awsSecretAccessKey;
public String getAwsAccessKeyId() {
return awsAccessKeyId;
}
public void setAwsAccessKeyId(String awsAccessKeyId) {
this.awsAccessKeyId = awsAccessKeyId;
}
public String getAwsSecretAccessKey() {
return awsSecretAccessKey;
}
public void setAwsSecretAccessKey(String awsSecretAccessKey) {
this.awsSecretAccessKey = awsSecretAccessKey;
}
}
- 修改
Application类 ：
修改Application类以使用从 Vault 读取的凭证创建 S3 客户端：
package com.packtpub.microservices.ch06.attachment;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.packtpub.microservices.ch06.attachment.config.Configuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
@Autowired
private Configuration config;
@Bean
public AmazonS3 getS3Client() {
AWSCredentials credentials = new BasicAWSCredentials(
config.getAwsAccessKeyId(),
config.getAwsSecretAccessKey()
);
AmazonS3ClientBuilder client = AmazonS3ClientBuilder.standard();
return client.withCredentials(new AWSStaticCredentialsProvider(credentials))
.withRegion(Regions.US_WEST_2)
.build();
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
4.3 总结
通过以上步骤，我们成功地将 attachment-service 集成了 Vault，实现了敏感配置数据的安全存储和访问。使用 Vault 可以提供更好的安全性，包括访问日志审计、细粒度的访问控制和密钥轮换等功能。
以下是集成 Vault 的步骤总结表格：
| 步骤 | 操作 | 命令/代码 |
| — | — | — |
| 1 | 安装 Vault | $ brew install vault （macOS X + HomeBrew） |
| 2 | 启动开发模式 | $ vault server --dev --dev-root-token-id="00000000-0000-0000-0000-000000000000" |
| 3 | 启用 kv 引擎 | $ vault secrets enable -path=secret/attachment-service |
| 4 | 写入 AWS 凭证 | $ vault write secret/attachment-service attachment.awsAccessKeyId=<access-key> attachment.awsSecretAccessKey=<access-secret> |
| 5 | 添加依赖 | 在 build.gradle 中添加 compile group: 'org.springframework.cloud', name: 'spring-cloud-starter-vault-config', version: '1.1.1.RELEASE' |
| 6 | 创建配置类 | Configuration 类 |
| 7 | 修改 Application 类 | 使用从 Vault 读取的凭证创建 S3 客户端 |
下面是集成 Vault 的流程图：
graph LR
A[安装 Vault] --> B[启动开发模式]
B --> C[启用 kv 引擎]
C --> D[写入 AWS 凭证]
D --> E[添加依赖到 build.gradle]
E --> F[创建配置类]
F --> G[修改 Application 类]
通过这些步骤，我们不仅提高了服务的安全性，还实现了敏感配置的集中管理和安全访问。在实际生产环境中，还需要进一步考虑 Vault 的高可用性、备份恢复等方面的配置，以确保系统的稳定性和安全性。
5. 安全配置的重要性及最佳实践总结
5.1 安全配置的重要性
在微服务架构中，安全配置是保障系统稳定运行和数据安全的关键因素。从服务请求状态分析可知，不同的状态码能反映出服务的不同问题，如 404 表示资源未找到，401 表示未授权访问。这提示我们在开发和部署过程中，要确保请求的正确性和授权的有效性，避免出现安全漏洞。
容器技术虽然为微服务架构带来了诸多便利，如资源优化和不可变基础设施的实现，但也引入了新的安全风险。多租户环境下，同一虚拟机上多个服务的运行使得攻击者可能利用一个服务的漏洞攻击其他服务。因此，使用 seccomp 等安全机制对容器进行沙箱化处理，限制系统调用，能有效提高容器的安全性。
配置管理方面，将配置与代码分离是至关重要的。硬编码配置不仅不利于维护，还会使敏感信息暴露给所有有权访问源代码的人。使用环境变量存储非敏感配置是一种常见的做法，但对于敏感信息，如数据库凭证和 AWS 访问密钥，需要更安全的存储方式，如 Vault。
5.2 最佳实践总结
以下是一些微服务安全配置的最佳实践总结：
1. 服务请求处理 ：
- 对不同的状态码进行合理处理，如 404 状态码提示资源未找到，可在代码中进行相应的错误处理和提示。
- 确保请求的授权机制正确，避免未授权访问。
2. 容器安全 ：
- 检查 Linux 内核是否支持 seccomp，并使用其策略对容器进行沙箱化处理。
- 定期审查和更新容器的安全配置，及时修复发现的漏洞。
3. 配置管理 ：
- 将配置与代码分离，使用环境变量存储非敏感配置。
- 对于敏感信息，使用专门的安全存储系统，如 Vault，进行安全存储和访问。
- 定期轮换密钥和凭证，降低信息泄露的风险。
6. 未来发展趋势及建议
6.1 未来发展趋势
随着微服务架构的不断发展，安全配置领域也将呈现出一些新的趋势：
1. 零信任架构的普及 ：零信任架构基于“默认不信任，始终验证”的原则，对任何试图访问系统的用户、设备和服务都进行严格的身份验证和授权。在微服务环境中，零信任架构将有助于进一步提高系统的安全性。
2. 人工智能和机器学习在安全中的应用 ：人工智能和机器学习技术可以用于分析大量的安全数据，检测异常行为和潜在的安全威胁。例如，通过机器学习算法对服务请求进行实时监测，及时发现并阻止恶意攻击。
3. 云原生安全的加强 ：随着越来越多的微服务应用部署在云端，云原生安全将成为未来的重点。云服务提供商将不断加强其安全功能，如提供更高级的加密技术和访问控制机制。
6.2 建议
为了应对未来的安全挑战，开发者和运维人员可以采取以下建议：
1. 持续学习和关注安全领域的发展 ：及时了解最新的安全技术和趋势，不断提升自己的安全意识和技能。
2. 进行安全测试和漏洞扫描 ：定期对微服务应用进行安全测试和漏洞扫描，及时发现并修复潜在的安全问题。
3. 建立完善的安全管理制度 ：制定严格的安全策略和流程，确保所有人员都遵守安全规定。
7. 总结
本文围绕微服务安全与配置管理展开，详细介绍了服务请求状态分析、容器安全、安全配置以及 Vault 的集成等方面的内容。通过对这些内容的学习，我们可以更好地理解微服务架构中的安全挑战，并掌握相应的解决方法。
在实际应用中，我们应根据具体的业务需求和安全要求，选择合适的安全配置方案。同时，要不断关注安全领域的发展趋势，及时调整和优化安全策略，以确保微服务系统的安全性和稳定性。
以下是整个微服务安全配置流程的总结表格：
| 阶段 | 操作内容 | 关键技术/工具 |
| — | — | — |
| 服务请求处理 | 分析请求状态码，确保请求正确性和授权有效性 | 无 |
| 容器安全 | 使用 seccomp 对容器进行沙箱化处理 | seccomp |
| 配置管理 | 分离配置与代码，使用环境变量存储非敏感信息，使用 Vault 存储敏感信息 | 环境变量、Vault |
| Vault 集成 | 安装、配置 Vault，修改项目代码以集成 Vault | Vault、Spring Cloud Vault Config |
下面是整个微服务安全配置流程的 mermaid 流程图：
graph LR
A[服务请求处理] --> B[容器安全]
B --> C[配置管理]
C --> D[Vault 集成]
A --> E[分析请求状态码]
B --> F[seccomp 沙箱化]
C --> G[分离配置与代码]
C --> H[使用环境变量]
C --> I[使用 Vault]
D --> J[安装 Vault]
D --> K[配置 Vault]
D --> L[修改项目代码]
通过遵循这些步骤和最佳实践，我们可以构建一个更加安全、稳定的微服务系统。
扫一扫
7480
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
