java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

转x33g5p2x  于2022-07-11 转载在 Java  
字(14.7k)|赞(0)|评价(0)|浏览(1134)

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

本篇概览

  • 本篇是《java与es8实战》系列的第五篇，总体目标明确：实战在SpringBoot应用中操作elasticsearch8，今天的重点是SpringBoot应用连接带有安全检查的elasticsearch8服务端
  • 连接需要安全检查的elasticsearch8是为了更接近真实环境，首先，连接是基于自签证书的https协议，其次，认证方式有两种
  1. 第一种是账号密码
  2. 第二种是es服务端授权的API Key
  • 以上两种认证方式，在今天的实战中都会尝试，再加上前文《java与es8实战之四：SpringBoot应用中操作es8(无安全检查)》，可以小小的梳理一下SpringBoot应用连接es8的方式了，如下所示，直连、证书+账号密码、证书+API key等三种

  • 今天的实战总体目标可以拆解为两个子任务
  1. 在SpringBoot中连接elasticsearch8
  2. 在SpringBoot中使用elasticsearch8官方的Java API Client
  • 接下来直接开始

部署elasticsearch集群(需要安全检查)

创建API Key

  • 除了账号密码，ES还提供了一种安全的访问方式：API Key，java应用持有es签发的API Key也能顺利发送指令到es，接下来咱们先生成API Key，再在应用中使用此API Key
  • 《docker-compose快速部署elasticsearch-8.x集群+kibana》一文中，的咱们将自签证书从容器中复制出来了，现在在证书所在目录执行以下命令，注意参数expiration代表这个ApiKey的有效期，我这里随意设置为10天
  1. curl -X POST "https://localhost:9200/_security/api_key?pretty" \
  2. --cacert es01.crt \
  3. -u elastic:123456 \
  4. -H 'Content-Type: application/json' \
  5. -d'
  6. {
  7.   "name": "my-api-key-10d",
  8.   "expiration": "10d"
  9. }
  10. '
  • 会收到以下响应，其中的encoded字段就是API Key
  1. {
  2.   "id" : "eUV1V4EBucGIxpberGuJ",
  3.   "name" : "my-api-key-10d",
  4.   "expiration" : 1655893738633,
  5.   "api_key" : "YyhSTh9ETz2LKBk3-Iy2ew",
  6.   "encoded" : "ZVVWMVY0RUJ1Y0dJeHBiZXJHdUo6WXloU1RoOUVUejJMS0JrMy1JeTJldw=="
  7. }

Java应用连接elasticsearch的核心套路

  • 不论是直连，还是带安全检查的连接，亦或是与SpringBoot的集成使之更方便易用，都紧紧围绕着一个不变的核心套路，该套路由两部分组成，掌握了它们就能在各种条件下成功连接es
  1. 首先，是builder pattern，连接es有关的代码，各种对象都是其builder对象的build方法创建的，建议您提前阅读《java与es8实战之一》一文，看完后，满屏的builder代码可以从丑变成美…
  2. 其次，就是java应用能向es发请求的关键：ElasticsearchClient对象，该对象的创建是有套路的，如下图，先创建RestClient，再基于RestClient创建ElasticsearchTransport，最后基于ElasticsearchTransport创建ElasticsearchClient，这是个固定的套路，咱们后面的操作都是基于此的，可能会加一点东西，但不会改变流程和图中的对象

  • 准备完毕，开始写代码

新建子工程

  • 为了便于管理依赖库版本和源码，《java与es8实战》系列的所有代码都以子工程的形式存放在父工程elasticsearch-tutorials中
  • 《java与es8实战之二：实战前的准备工作》一文说明了创建父工程的详细过程
  • 在父工程elasticsearch-tutorials中新建名为crud-with-security的子工程，其pom.xml内容如下
  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <!-- 请改为自己项目的parent坐标 -->
  6.     <parent>
  7.         <artifactId>elasticsearch-tutorials</artifactId>
  8.         <groupId>com.bolingcavalry</groupId>
  9.         <version>1.0-SNAPSHOT</version>
  10.         <relativePath>../pom.xml</relativePath>
  11.     </parent>
  12.     <modelVersion>4.0.0</modelVersion>
  13.     <groupId>com.bolingcavalry</groupId>
  14.     <!-- 请改为自己项目的artifactId -->
  15.     <artifactId>crud-with-security</artifactId>
  16.     <packaging>jar</packaging>
  17.     <!-- 请改为自己项目的name -->
  18.     <name>crud-with-security</name>
  19.     <version>1.0-SNAPSHOT</version>
  20.     <url>https://github.com/zq2599</url>
  22.     <!--不用spring-boot-starter-parent作为parent时的配置-->
  23.     <dependencyManagement>
  24.         <dependencies>
  25.             <dependency>
  26.                 <groupId>org.springframework.boot</groupId>
  27.                 <artifactId>spring-boot-dependencies</artifactId>
  29.                 <version>${springboot.version}</version>
  30.                 <type>pom</type>
  31.                 <scope>import</scope>
  32.             </dependency>
  33.         </dependencies>
  34.     </dependencyManagement>
  36.     <dependencies>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  42.         <!-- 不加这个，configuration类中，IDEA总会添加一些提示 -->
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-configuration-processor</artifactId>
  46.             <optional>true</optional>
  47.         </dependency>
  49.         <dependency>
  50.             <groupId>org.projectlombok</groupId>
  51.             <artifactId>lombok</artifactId>
  52.         </dependency>
  54.         <dependency>
  55.             <groupId>org.springframework.boot</groupId>
  56.             <artifactId>spring-boot-starter-web</artifactId>
  57.         </dependency>
  59.         <dependency>
  60.             <groupId>org.springframework.boot</groupId>
  61.             <artifactId>spring-boot-starter-test</artifactId>
  62.             <scope>test</scope>
  64.             <!-- exclude junit 4 -->
  65.             <exclusions>
  66.                 <exclusion>
  67.                     <groupId>junit</groupId>
  68.                     <artifactId>junit</artifactId>
  69.                 </exclusion>
  70.             </exclusions>
  72.         </dependency>
  74.         <!-- junit 5 -->
  75.         <dependency>
  76.             <groupId>org.junit.jupiter</groupId>
  77.             <artifactId>junit-jupiter-api</artifactId>
  78.             <scope>test</scope>
  79.         </dependency>
  81.         <dependency>
  82.             <groupId>org.junit.jupiter</groupId>
  83.             <artifactId>junit-jupiter-engine</artifactId>
  84.             <scope>test</scope>
  85.         </dependency>
  87.         <!-- elasticsearch引入依赖  start -->
  88.         <dependency>
  89.             <groupId>co.elastic.clients</groupId>
  90.             <artifactId>elasticsearch-java</artifactId>
  91.         </dependency>
  93.         <dependency>
  94.             <groupId>com.fasterxml.jackson.core</groupId>
  95.             <artifactId>jackson-databind</artifactId>
  96.         </dependency>
  98.         <!-- 使用spring boot Maven插件时需要添加该依赖 -->
  99.         <dependency>
  100.             <groupId>jakarta.json</groupId>
  101.             <artifactId>jakarta.json-api</artifactId>
  102.         </dependency>
  104.         <dependency>
  105.             <groupId>org.springframework.boot</groupId>
  106.             <artifactId>spring-boot-starter-web</artifactId>
  107.         </dependency>
  108.     </dependencies>
  110.     <build>
  111.         <plugins>
  112.             <!-- 需要此插件，在执行mvn test命令时才会执行单元测试 -->
  113.             <plugin>
  114.                 <groupId>org.apache.maven.plugins</groupId>
  115.                 <artifactId>maven-surefire-plugin</artifactId>
  116.                 <version>3.0.0-M4</version>
  117.                 <configuration>
  118.                     <skipTests>false</skipTests>
  119.                 </configuration>
  120.             </plugin>
  122.             <plugin>
  123.                 <groupId>org.springframework.boot</groupId>
  124.                 <artifactId>spring-boot-maven-plugin</artifactId>
  125.                 <configuration>
  126.                     <excludes>
  127.                         <exclude>
  128.                             <groupId>org.projectlombok</groupId>
  129.                             <artifactId>lombok</artifactId>
  130.                         </exclude>
  131.                     </excludes>
  132.                 </configuration>
  133.             </plugin>
  134.         </plugins>
  136.         <resources>
  137.             <resource>
  138.                 <directory>src/main/resources</directory>
  139.                 <includes>
  140.                     <include>**/*.*</include>
  141.                 </includes>
  142.             </resource>
  143.         </resources>
  144.     </build>
  145. </project>

配置文件

  • 为了成功连接es，需要两个配置文件：SpringBoot常规的配置application.yml和es的自签证书
  • 首先是application.yml，如下所示，因为本篇要验证两种授权方式，所以账号、密码、apiKey全部填写在配置文件中，如下所示
  1. elasticsearch:
  2.   username: elastic
  3.   passwd: 123456
  4.   apikey: ZVVWMVY0RUJ1Y0dJeHBiZXJHdUo6WXloU1RoOUVUejJMS0JrMy1JeTJldw==
  5.   # 多个IP逗号隔开
  6.   hosts: 127.0.0.1:9200

编码：启动类

  • SpringBoot启动类，平淡无奇的那种
  1. @SpringBootApplication
  2. public class SecurityApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(SecurityApplication.class, args);
  5.     }
  6. }

编码：配置文件

  • 接下来是全文的重点：通过Config类向Spring环境注册服务bean，这里有这两处要注意的地方
  • 第一个要注意的地方：向Spring环境注册的服务bean一共有两个，它们都是ElasticsearchClient类型，一个基于账号密码认证，另一个基于apiKey认证
  • 第二个要注意的地方：SpringBoot向es服务端发起的是https请求，这就要求在建立连接的时候使用正确的证书，也就是刚才咱们从容器中复制出来再放入application.yml所在目录的es01.crt文件，使用证书的操作发生在创建ElasticsearchTransport对象的时候，属于前面总结的套路步骤中的一步，如下图红框所示

  • 配置类的详细代码如下，有几处需要注意的地方稍后会说明
  1. package com.bolingcavalry.security.config;
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import co.elastic.clients.json.jackson.JacksonJsonpMapper;
  5. import co.elastic.clients.transport.ElasticsearchTransport;
  6. import co.elastic.clients.transport.rest_client.RestClientTransport;
  7. import lombok.Setter;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.apache.http.Header;
  10. import org.apache.http.HttpHost;
  11. import org.apache.http.auth.AuthScope;
  12. import org.apache.http.auth.UsernamePasswordCredentials;
  13. import org.apache.http.client.CredentialsProvider;
  14. import org.apache.http.conn.ssl.NoopHostnameVerifier;
  15. import org.apache.http.impl.client.BasicCredentialsProvider;
  16. import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
  17. import org.apache.http.message.BasicHeader;
  18. import org.apache.http.ssl.SSLContextBuilder;
  19. import org.apache.http.ssl.SSLContexts;
  20. import org.elasticsearch.client.RestClient;
  21. import org.elasticsearch.client.RestClientBuilder;
  22. import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
  23. import org.springframework.boot.context.properties.ConfigurationProperties;
  24. import org.springframework.context.annotation.Bean;
  25. import org.springframework.context.annotation.Configuration;
  26. import org.springframework.core.io.ClassPathResource;
  27. import org.springframework.util.StringUtils;
  29. import javax.net.ssl.SSLContext;
  30. import java.io.IOException;
  31. import java.io.InputStream;
  32. import java.nio.file.Files;
  33. import java.nio.file.Path;
  34. import java.nio.file.Paths;
  35. import java.security.KeyManagementException;
  36. import java.security.KeyStore;
  37. import java.security.KeyStoreException;
  38. import java.security.NoSuchAlgorithmException;
  39. import java.security.cert.Certificate;
  40. import java.security.cert.CertificateException;
  41. import java.security.cert.CertificateFactory;
  43. @ConfigurationProperties(prefix = "elasticsearch") //配置的前缀
  44. @Configuration
  45. @Slf4j
  46. public class ClientConfig {
  48.     @Setter
  49.     private String hosts;
  51.     @Setter
  52.     private String username;
  54.     @Setter
  55.     private String passwd;
  57.     @Setter
  58.     private String apikey;
  60.     /**
  61.      * 解析配置的字符串，转为HttpHost对象数组
  62.      * @return
  63.      */
  64.     private HttpHost[] toHttpHost() {
  65.         if (!StringUtils.hasLength(hosts)) {
  66.             throw new RuntimeException("invalid elasticsearch configuration");
  67.         }
  69.         String[] hostArray = hosts.split(",");
  70.         HttpHost[] httpHosts = new HttpHost[hostArray.length];
  71.         HttpHost httpHost;
  72.         for (int i = 0; i < hostArray.length; i++) {
  73.             String[] strings = hostArray[i].split(":");
  74.             httpHost = new HttpHost(strings[0], Integer.parseInt(strings[1]), "https");
  75.             httpHosts[i] = httpHost;
  76.         }
  78.         return httpHosts;
  79.     }
  81.     @Bean
  82.     public ElasticsearchClient clientByPasswd() throws Exception {
  83.         ElasticsearchTransport transport = getElasticsearchTransport(username, passwd, toHttpHost());
  84.         return new ElasticsearchClient(transport);
  85.     }
  87.     private static SSLContext buildSSLContext() {
  88.         ClassPathResource resource = new ClassPathResource("es01.crt");
  89.         SSLContext sslContext = null;
  90.         try {
  91.             CertificateFactory factory = CertificateFactory.getInstance("X.509");
  92.             Certificate trustedCa;
  93.             try (InputStream is = resource.getInputStream()) {
  94.                 trustedCa = factory.generateCertificate(is);
  95.             }
  96.             KeyStore trustStore = KeyStore.getInstance("pkcs12");
  97.             trustStore.load(null, null);
  98.             trustStore.setCertificateEntry("ca", trustedCa);
  99.             SSLContextBuilder sslContextBuilder = SSLContexts.custom()
  100.                     .loadTrustMaterial(trustStore, null);
  101.             sslContext = sslContextBuilder.build();
  102.         } catch (CertificateException | IOException | KeyStoreException | NoSuchAlgorithmException |
  103.                  KeyManagementException e) {
  104.             log.error("ES连接认证失败", e);
  105.         }
  107.         return sslContext;
  108.     }
  110.     private static ElasticsearchTransport getElasticsearchTransport(String username, String passwd, HttpHost...hosts) {
  111.         // 账号密码的配置
  112.         final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
  113.         credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, passwd));
  115.         // 自签证书的设置，并且还包含了账号密码
  116.         HttpClientConfigCallback callback = httpAsyncClientBuilder -> httpAsyncClientBuilder
  117.                 .setSSLContext(buildSSLContext())
  118.                 .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
  119.                 .setDefaultCredentialsProvider(credentialsProvider);
  121.         // 用builder创建RestClient对象
  122.         RestClient client = RestClient
  123.                            .builder(hosts)
  124.                            .setHttpClientConfigCallback(callback)
  125.                            .build();
  127.         return new RestClientTransport(client, new JacksonJsonpMapper());
  128.     }
  130.     private static ElasticsearchTransport getElasticsearchTransport(String apiKey, HttpHost...hosts) {
  131.         // 将ApiKey放入header中
  132.         Header[] headers = new Header[] {new BasicHeader("Authorization", "ApiKey " + apiKey)};
  134.         // es自签证书的设置
  135.         HttpClientConfigCallback callback = httpAsyncClientBuilder -> httpAsyncClientBuilder
  136.                 .setSSLContext(buildSSLContext())
  137.                 .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE);
  139.         // 用builder创建RestClient对象
  140.         RestClient client = RestClient
  141.                            .builder(hosts)
  142.                            .setHttpClientConfigCallback(callback)
  143.                            .setDefaultHeaders(headers)
  144.                            .build();
  146.         return new RestClientTransport(client, new JacksonJsonpMapper());
  147.     }
  149.     @Bean
  150.     public ElasticsearchClient clientByApiKey() throws Exception {
  151.         ElasticsearchTransport transport = getElasticsearchTransport(apikey, toHttpHost());
  152.         return new ElasticsearchClient(transport);
  153.     }
  154. }
  • 上述代码有以下几处需要注意
  1. 这个配置类为业务代码提供了两个服务bean，作用是操作es，这两个服务bean分别由clientByPasswd和clientByApiKey两个方法负责提供
  2. 名为getElasticsearchTransport的方法有两个，分别负责配置两种鉴权方式：账号密码和apiKey
  3. 设置证书的操作被封装在buildSSLContext方法中，在创建ElasticsearchTransport对象的时候会用到

编码：业务类

  • 既然两个ElasticsearchClient对象都已经注册到Spring环境，那么只要在业务类中注入就能用来操作es了
  • 新建业务类ESService.java，如下，可见通过Resource注解选择了账号密码鉴权的ElasticsearchClient对象
  1. package com.bolingcavalry.security.service;
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  7. import javax.annotation.Resource;
  8. import java.io.IOException;
  10. @Service
  11. public class ESService {
  13.     @Resource(name="clientByPasswd")
  14.     private ElasticsearchClient elasticsearchClient;
  16.     public void addIndex(String name) throws IOException {
  17.         elasticsearchClient.indices().create(c -> c.index(name));
  18.     }
  20.     public boolean indexExists(String name) throws IOException {
  21.         return elasticsearchClient.indices().exists(b -> b.index(name)).value();
  22.     }
  24.     public void delIndex(String name) throws IOException {
  25.         elasticsearchClient.indices().delete(c -> c.index(name));
  26.     }
  27. }
  • 至此，基本功能算是开发完成了，接下来编写单元测试代码，验证能否成功操作es8

编码：单元测试

  • 新增单元测试类ESServiceTest.java，如下，功能是调用业务类ESService执行创建、删除、查找等索引操作
  1. package com.bolingcavalry.security.service;
  3. import org.junit.jupiter.api.Assertions;
  4. import org.junit.jupiter.api.Test;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  8. @SpringBootTest
  9. class ESServiceTest {
  11.     @Autowired
  12.     ESService esService;
  14.     @Test
  15.     void addIndex() throws Exception {
  16.         String indexName = "test_index";
  18.         Assertions.assertFalse(esService.indexExists(indexName));
  19.         esService.addIndex(indexName);
  20.         Assertions.assertTrue(esService.indexExists(indexName));
  21.         esService.delIndex(indexName);
  22.         Assertions.assertFalse(esService.indexExists(indexName));
  23.     }
  24. }
  • 编码完成，开始验证

验证：账号密码鉴权

  • 现在ESService中使用的es服务类是账号密码鉴权的，运行单元测试，看看是否可以成功操作ES，如下图，符合预期

验证：ApiKey鉴权

  • 再来试试ApiKey鉴权操作es，修改ESService.java源码，改动如下图红框所示

  • 为了检查创建的索引是否符合预期，注释掉单元测试类中删除索引的代码，如下图，如此一来，单元测试执行完成后，新增的索引还保留在es环境中

  • 再执行一次单元测试，依旧符合预期

  • 用eshead查看，可见索引创建成功

  • 至此，SpringBoot操作带有安全检查的elasticsearch8的实战就完成了，在SpringData提供elasticsearch8操作的库之前，基于es官方原生client库的操作是常见的elasticsearch8访问方式，希望本文能给您一些参考

源码下载

  • 本篇实战的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)
名称链接备注
项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页
git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议
git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议
  • 这个git项目中有多个文件夹，本次实战的源码在elasticsearch-tutorials文件夹下，如下图红框

  • elasticsearch-tutorials是个父工程，里面有多个module，本篇实战的module是crud-with-security，如下图红框

你不孤单，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://xinchen.blog.csdn.net/article/details/125712512

内容来源于网络，如有侵权，请联系作者删除！

Javajava服务端

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com