分布式文件系统使用——MinIO

ゞ浴缸里的玫瑰 2024-03-27 17:01 10阅读 0赞

## 分布式文件系统使用——MinIO ##

### 1 分布式文件系统 ###

#### 1.1 概念 ####

![在这里插入图片描述][24c480b40ba74c179020d8711105e2a5.png]

*  常见的文件系统：FAT16/FAT32、NTFS、HFS、UFS、APFS、XFS、Ext4等 。

> 现在有个问题，一此短视频平台拥有大量的视频、图片，这些视频文件、图片文件该如何存储呢？如何存储可以满足互联网上海量用户的浏览。  
> `分布式文件系统`就是海量用户查阅海量文件的方案。

通过概念可以简单理解为：一个计算机无法存储海量的文件，通过网络将若干计算机组织起来共同去存储海量的文件，去接收海量用户的请求，这些组织起来的计算机通过网络进行通信，如下图：  
![在这里插入图片描述][f1127db42dae4cc1ba83205fbc979a13.png]

分布式文件系统的好处：

1.  一台计算机的文件系统处理能力扩充到多台计算机同时处理
2.  一台计算机挂了还有另外副本计算机提供数据
3.  每台计算机可以放在不同的地域，这样用户就可以就近访问，提高访问速度

总结：干活的人多、有副本、就近访问

#### 1.2 常见的分布式文件系统 ####

##### ①NFS #####

> 类比`网络上的共享文件夹`方式

![在这里插入图片描述][8fbd489a3566436bb312d620bf0a45c3.png]

1）在客户端上映射NFS服务器的驱动器。
    2）客户端通过网络访问NFS服务器的硬盘完全透明。

##### ②GFS（google） #####

> 主从结构：master、chunkserver

![在这里插入图片描述][e5905f53187349b794edbc34e3e020f2.png]

1）GFS采用主从结构，一个GFS集群由一个master和大量的chunkserver组成。
    2）master存储了数据文件的元数据，一个文件被分成了若干块存储在多个chunkserver中。
    3）用户从master中获取数据元信息，向chunkserver存储数据。

##### ③HDFS #####

> HDFS，是Hadoop Distributed File System的简称，是Hadoop抽象文件系统的一种实现。HDFS是一个高度容错性的系统，适合部署在廉价的机器上。HDFS能提供高吞吐量的数据访问，非常适合大规模数据集上的应用。 HDFS的文件分布在集群机器上，同时提供副本进行容错及可靠性保证。例如客户端写入读取文件的直接操作都是分布在集群各个机器上的，没有单点性能压力。

![在这里插入图片描述][86aef7156e9e4b33b5266cd1bf838423.png]

1）HDFS采用主从结构，一个HDFS集群由一个名称结点和若干数据结点组成。
    2) 名称结点存储数据的元信息，一个完整的数据文件分成若干块存储在数据结点。
    3）客户端从名称结点获取数据的元信息及数据分块的信息，得到信息客户端即可从
    数据块来存取数据。

##### ④云计算厂家（类似：阿里的OOS） #####

> 阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。

> 百度对象存储BOS提供稳定、安全、高效、高可扩展的云存储服务。

##### ⑤MinIO（去中心化） #####

> MinIO 是一个非常轻量的服务,可以很简单的和其他应用的结合使用，它兼容亚马逊 S3 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。  
> 它一大特点就是轻量，使用简单，功能强大，支持各种平台，单个文件最大5TB，兼容 Amazon S3接口，提供了 Java、Python、GO等多版本SDK支持。

### 2 MinIO教程 ###

#### 2.1 MinIO概念 ####

MinIO是一个轻量级的服务，但是服务功能齐全，我们日常的小项目可以用它来做我们的分布式文件系统。

> 官网：https://min.io  
> 中文：https://www.minio.org.cn/，http://docs.minio.org.cn/docs/

MinIO集群采用去中心化共享架构，每个结点是对等关系，通过Nginx可对MinIO进行负载均衡访问。

>  *  在大数据领域，通常的设计理念都是无中心和分布式。Minio分布式模式可以帮助你搭建一个高可用的对象存储服务，你可以使用这些存储设备，而不用考虑其真实物理位置。
>  *  它将分布在不同服务器上的多块硬盘组成一个对象存储服务。由于硬盘分布在不同的节点上，分布式Minio避免了单点故障。

结构图如下：  
![在这里插入图片描述][6f91c47b76384ff895815c2477ae6797.png]

> 1.  Minio使用纠删码技术来保护数据，它是一种恢复丢失和损坏数据的数学算法，它将数据分块冗余的分散存储在各各节点的磁盘上，所有的可用磁盘组成一个集合
> 2.  使用纠删码的好处是即便丢失一半数量（N/2）的硬盘，仍然可以恢复数据。 比如上边集合中有4个以内的硬盘损害仍可保证数据恢复，不影响上传和下载，如果多于一半的硬盘坏了则无法恢复。

如上图，一共4个server，如果有1个server挂了，依然可以上传和下载文件，并且当挂
    掉的server恢复后，会自动恢复数据。
    "如果多于一半的server挂了，那么无法恢复"，比如：如果有两个挂了，就算server重
    新上线，也依然无法恢复数据，数据将无法同步，这对分布式文件系统DFS是致命的。

#### 2.2 使用MinIO ####

> 从MinIO官网下载对应操作系统版本，这里以windows为例

①下载好后，创建存放文件的目标文件夹，进入MinIO的cmd执行以下命令

> 照理来说是应该有多台机器的，但是由于条件限制，采用创建几个文件夹来模拟分布式【大家可以通过虚拟机的方式模拟】

*  此处我创建四个data文件：  
    ![在这里插入图片描述][6b913d07dd564358ae4222c9ae54b765.png]
 *  执行命令完成映射：

> minio.exe server D:\\develop\\minio\_data\\data1 D:\\develop\\minio\_data\\data2 D:\\develop\\minio\_data\\data3 D:\\develop\\minio\_data\\data4

![在这里插入图片描述][6c5d3440858443eca25574595d0f43f0.png]

*  输入url，进入minio的管理页面

> 复制上面cmd窗口中展示的任意一个url【端口为：9000】  
> 例如：http://169.254.133.199:9000  
> 用户名、密码默认都是：minioadmin

![在这里插入图片描述][0d7489b5e4b648d88e4bad156fef4fc0.png]  
②创建bucket

> 下一步创建bucket，桶，它相当于存储文件的目录，可以创建若干的桶

![在这里插入图片描述][3b3a35ecf524474c9a0dd70f842a69ad.png]  
③点击“upload”上传文件。  
![在这里插入图片描述][e055432bda7f4032bb7629e3ba4e086f.png]  
④观察本地四个data目录情况  
![在这里插入图片描述][f7015e3fa1b94d29a0f88a72283a7c9d.png]

> 我们发现上传的1.mp4文件存储在了四个目录，即四个硬盘上。  
> 下边测试minio的数据恢复过程：  
> 1、首先删除一个目录。  
> 删除目录后仍然可以在web控制台上传文件和下载文件。  
> 稍等片刻删除的目录自动恢复。  
> 2、删除两个目录。  
> 删除两个目录也会自动恢复。  
> 3、删除三个目录 。  
> 由于 集合中共有4块硬盘，有大于一半的硬盘损坏数据无法恢复。  
> 此时报错：We encountered an internal error, please try again. (Read failed. Insufficient number of drives online)在线驱动器数量不足。

#### 2.3 Java操作MinIO ####

> MinIO提供多个语言版本SDK的支持，下边找到java版本的文档：  
> 地址：https://docs.min.io/docs/java-client-quickstart-guide.html  
> 最低需求Java 1.8或更高版本:

##### 2.3.1 导入依赖 #####

<dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>8.4.3</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.8.1</version>
    </dependency>

##### 2.3.2 测试上传 #####

1.  创建bucket  
    ![在这里插入图片描述][0a178dc90ca64927b7ef2fa3e2f2784c.png]
2.  点击“Manage”修改bucket的访问权限，改为public  
    ![在这里插入图片描述][6d2bdc770724426a9cedeb56313f5e79.png]  
    ![在这里插入图片描述][9f4f41c502d643c9b069c6d05d9f3afe.png]

> public，任意人都可访问

1.  创建一个路径：file【如果不创建，运行下面的代码会自动创建】  
    ![在这里插入图片描述][32d002e3f8f64258be6b9203cf6b6de6.png]
2.  测试代码

package com.zi.test;
    
    import io.minio.BucketExistsArgs;
    import io.minio.MakeBucketArgs;
    import io.minio.MinioClient;
    import io.minio.UploadObjectArgs;
    import io.minio.errors.MinioException;
    
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    /**
     * @author zhouYi
     * @description TODO
     * @date 2023/2/14 17:47
     */
    public class MinIOTest {
        
    
        static MinioClient minioClient =
                MinioClient.builder()
                        //url先择任何一个server
                        .endpoint("http://169.254.133.199:9000")
                        //用户名密码
                        .credentials("minioadmin", "minioadmin")
                        .build();
    
    
        //上传文件
        public static void upload() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            try {
        
                boolean found =
                        minioClient.bucketExists(BucketExistsArgs.builder()
                                //选择testbucket
                                .bucket("testbucket").build());
                //检查testbucket桶是否创建，没有创建自动创建
                if (!found) {
        
                    minioClient.makeBucket(MakeBucketArgs.builder().bucket("testbucket").build());
                } else {
        
                    System.out.println("Bucket 'testbucket' already exists.");
                }
                //上传hello.txt
                minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket("testbucket")
                                .object("hello.txt")
                                .filename("D:\\hello.txt")
                                .build());
                //上传hello.txt,上传到txt子目录
                minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket("testbucket")
                                .object("txt/hello2.txt")
                                .filename("D:\\hello2.txt")
                                .build());
                System.out.println("上传成功");
            } catch (MinioException e) {
        
                System.out.println("Error occurred: " + e);
                System.out.println("HTTP trace: " + e.httpTrace());
            }
    
        }
    
        public static void main(String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            upload();
        }
    
    
    }

> 上面的参数说明：

![在这里插入图片描述][c1698173475645f882c427aac6501db7.png]  
5. 结果

运行main方法，查看结果：  
![在这里插入图片描述][cd7e650716224ae589a8da451b988e6d.png]  
在MinIO的控制台查看：

http://169.254.133.199:9000

![在这里插入图片描述][0c97c38ca659496ea3ed50a004de6b91.png]

![在这里插入图片描述][b4aa87eb587c4503b67b62e2c70d80eb.png]

##### 2.3.3 测试删除 #####

//连接的MinIO服务器同上文
    ...
    //删除文件
    public static void delete(String bucket,String filepath)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
        try {
        
    
            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucket).object(filepath).build());
            System.out.println("删除成功");
        } catch (MinioException e) {
        
            System.out.println("Error occurred: " + e);
            System.out.println("HTTP trace: " + e.httpTrace());
        }
    
    }
    
    public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
    //  upload();
        delete("testbucket","hello.txt");
        delete("testbucket","txt/hello2.txt");
    
    }
    ...

![在这里插入图片描述][0b96069fde2f491b83ade87553bd46fc.png]

> 删除成功！

##### 2.3.4 查询文件是否存在 #####

> 重新上传文件，然后查询文件是否存在，是否存在，下载到本地

![在这里插入图片描述][35267e61cdad49f28353f327722eb28b.png]

//连接MinIO的服务器同上
    ...
        //下载文件
        public static void getFile(String bucket,String filepath,String outFile)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            try {
        
    
    
                try (InputStream stream = minioClient.getObject(
                        GetObjectArgs.builder()
                                .bucket(bucket)
                                .object(filepath)
                                .build());
                     FileOutputStream fileOutputStream = new FileOutputStream(new File(outFile));
                ) {
        
    
                    // Read data from stream
                    IOUtils.copy(stream,fileOutputStream);
                    System.out.println("下载成功");
                }
    
            } catch (MinioException e) {
        
                System.out.println("Error occurred: " + e);
                System.out.println("HTTP trace: " + e.httpTrace());
            }
    
        }
    
    
        public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            upload();
    //  delete("testbucket","hello.txt");
    //  delete("testbucket","txt/hello2.txt");
            getFile("testbucket","txt/hello2.txt","D:\\hello3.txt");
        }
        ...

![在这里插入图片描述][80a7826e5d5b41e390ba18e0abeb2273.png]

##### 2.3.5 全部测试代码 #####

public class MinIOTest {
        
    
        static MinioClient minioClient =
                MinioClient.builder()
                        //url先择任何一个server
                        .endpoint("http://169.254.133.199:9000")
                        //用户名密码
                        .credentials("minioadmin", "minioadmin")
                        .build();
    
    
        //上传文件
        public static void upload() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            try {
        
                boolean found =
                        minioClient.bucketExists(BucketExistsArgs.builder()
                                //选择testbucket
                                .bucket("testbucket").build());
                //检查testbucket桶是否创建，没有创建自动创建
                if (!found) {
        
                    minioClient.makeBucket(MakeBucketArgs.builder().bucket("testbucket").build());
                } else {
        
                    System.out.println("Bucket 'testbucket' already exists.");
                }
                //上传hello.txt
                minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket("testbucket")
                                .object("hello.txt")
                                .filename("D:\\hello.txt")
                                .build());
                //上传hello.txt,上传到txt子目录
                minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket("testbucket")
                                .object("txt/hello2.txt")
                                .filename("D:\\hello2.txt")
                                .build());
                System.out.println("上传成功");
            } catch (MinioException e) {
        
                System.out.println("Error occurred: " + e);
                System.out.println("HTTP trace: " + e.httpTrace());
            }
    
        }
    
    
    
        //删除文件
        public static void delete(String bucket,String filepath)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            try {
        
    
                minioClient.removeObject(
                        RemoveObjectArgs.builder().bucket(bucket).object(filepath).build());
                System.out.println("删除成功");
            } catch (MinioException e) {
        
                System.out.println("Error occurred: " + e);
                System.out.println("HTTP trace: " + e.httpTrace());
            }
    
        }
    
        //下载文件
        public static void getFile(String bucket,String filepath,String outFile)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            try {
        
    
    
                try (InputStream stream = minioClient.getObject(
                        GetObjectArgs.builder()
                                .bucket(bucket)
                                .object(filepath)
                                .build());
                     FileOutputStream fileOutputStream = new FileOutputStream(new File(outFile));
                ) {
        
    
                    // Read data from stream
                    IOUtils.copy(stream,fileOutputStream);
                    System.out.println("下载成功");
                }
    
            } catch (MinioException e) {
        
                System.out.println("Error occurred: " + e);
                System.out.println("HTTP trace: " + e.httpTrace());
            }
    
        }
    
    
        public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
            upload();
    //  delete("testbucket","hello.txt");
    //  delete("testbucket","txt/hello2.txt");
            getFile("testbucket","txt/hello2.txt","D:\\hello3.txt");
        }
    }

#### 2.4 MinIO整合SpringCloud项目 ####

> 文件上传是众多项目中比较基础的功能，但是其实现起来细节也很多，下面我将通过MinIO实现文件上传。

前置条件；已经导入好了项目，并且搭建好了nacos环境

##### 2.4.1 文件上传controller #####

> `SpringWeb提供了注解：@RequestPart`,同时指明文件类型consumes = \{MediaType.MULTIPART\_FORM\_DATA\_VALUE\}

/**
     * 上传文件
     * @param filedata
     * @param folder
     * @param objectName
     * @return
     */
    @RequestMapping(value = "/upload/coursefile", consumes = {
        MediaType.MULTIPART_FORM_DATA_VALUE})
    public UploadFileResultDto upload(@RequestPart("filedata")MultipartFile filedata,
                                      @RequestParam(value="folder", required = false) String folder,
                                      @RequestParam(value="objectName", required = false) String objectName){
        
        Long companyId = 1232141425L;
        //构建参数传给service
        UploadFileParamsDto uploadFileParamsDto = new UploadFileParamsDto();
        //判断文件类型
        String contentType = filedata.getContentType();
        uploadFileParamsDto.setContentType(contentType);
        uploadFileParamsDto.setFileSize(filedata.getSize());
        //contentType中的image/gif、image/jpeg、image/png都包含image
        if(contentType.indexOf("image") >= 0){
        
            //图片
            uploadFileParamsDto.setFileType("001001");
        }else{
        
            uploadFileParamsDto.setFileType("001003");
        }
        //文件名称
        uploadFileParamsDto.setFilename(filedata.getOriginalFilename());
        //构建返回对象
        UploadFileResultDto uploadFileResultDto = null;
        try{
        
            uploadFileResultDto = mediaFileService.uploadFile(companyId, uploadFileParamsDto, filedata.getBytes(), folder,objectName);
        } catch (Exception e) {
        
            XcPlusException.cast("上传文件过程出错");
        }
        return uploadFileResultDto;
    }

##### 2.4.2 文件上传interface、service、minioConfig #####

①interface

UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, byte[] bytes, String folder, String objectName);

②service

/**
     * 上传文件通用接口
     *
     * @param companyId
     * @param uploadFileParamsDto
     * @param bytes
     * @param folder
     * @param objectName
     * @return
     */
    @Override
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, byte[] bytes, String folder, String objectName) {
        
        //获取文件md5值【根据md5可以判断是否是同一文件】
        String fileMd5 = DigestUtils.md5Hex(bytes);
        if (StringUtils.isEmpty(folder)) {
        
            //如果没有传文件夹，自动按照年月日生成
            folder = getFileFolder(new Date(), true, true, true);
        } else if (folder.indexOf("/") < 0) {
        
            folder = folder + "/";
        }
        //文件名称
        String filename = uploadFileParamsDto.getFilename();
        if (StringUtils.isEmpty(objectName)) {
        
            //如果objectName为空，则使用文件的md5值为文件名
            objectName = fileMd5 + filename.substring(filename.lastIndexOf("."));
        }
        //上传到MinIO【文件夹路径+文件名】
        objectName = folder + objectName;
        try {
        
            //将文件的字节数组转换为字节输入流
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
            String contentType = uploadFileParamsDto.getContentType();
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucket_files)
                    .object(objectName)
                    //InputStream stream, long objectSize 对象大小, long partSize 分片大小(-1表示5M,最大不要超过5T，最多10000)
                    .stream(byteArrayInputStream, byteArrayInputStream.available(), -1)
                    .contentType(contentType)
                    .build();
            //上传到minio
            minioClient.putObject(putObjectArgs);
    
            //保存到数据库[存储文件使用的是md5值]
            MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
            if(mediaFiles == null){
        
                mediaFiles = new MediaFiles();
                //封装数据
                BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
                mediaFiles.setId(fileMd5);
                mediaFiles.setFileId(fileMd5);
                mediaFiles.setCompanyId(companyId);
                mediaFiles.setFilename(filename);
                mediaFiles.setBucket(bucket_files);
                mediaFiles.setFilePath(objectName);
                mediaFiles.setUrl("/" + bucket_files + "/" + objectName);
                mediaFiles.setCreateDate(LocalDateTime.now());
                mediaFiles.setStatus("1");
                mediaFiles.setAuditStatus("002003");
                //插入数据库【文件表】
                mediaFilesMapper.insert(mediaFiles);
            }
            //准备返回数据
            UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
            BeanUtils.copyProperties(mediaFiles, mediaFiles);
            return uploadFileResultDto;
        }catch (Exception e) {
        
            log.debug("上传文件失败：{}",e.getMessage());
        }
        return null;
    }
    
    //根据日期生成文件夹
    private String getFileFolder(Date date, boolean year, boolean month, boolean day) {
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //获取当前日期字符串
        String dataStr = sdf.format(new Date());
        //取出年月日
        String[] arr = dataStr.split("-");
        StringBuffer folderStr = new StringBuffer();
        if (year) {
        
            folderStr.append(arr[0]);
            folderStr.append("/");
        }
        if (month) {
        
            folderStr.append(arr[1]);
            folderStr.append("/");
        }
        if (day) {
        
            folderStr.append(arr[2]);
            folderStr.append("/");
        }
        return folderStr.toString();
    }

③minio配置类（从nacos读取配置）

/**
     * @author zhouYi
     * @description Minio配置类，配置Minio客户端
     * @date 2023/2/15 10:18
     */
    @Configuration
    public class MinioConfig {
        
    
        //从nacos读取参数
    
        //URL
        @Value("${minio.endpoint}")
        private String endpoint;
        //账号
        @Value("${minio.accessKey}")
        private String accessKey;
        //密码
        @Value("${secretKey}")
        private String secretKey;
    
        public MinioClient minioClient(){
        
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(endpoint)
                            .credentials(accessKey, secretKey)
                            .build();
            return minioClient;
        }
    }

[24c480b40ba74c179020d8711105e2a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/927b4464b03e452c85d4e136edd2077d.png
[f1127db42dae4cc1ba83205fbc979a13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c62cb8f19cf24889aa2eaa2bdb8cb283.png
[8fbd489a3566436bb312d620bf0a45c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/aff15d1eba5742e3b9d91cd880edea0d.png
[e5905f53187349b794edbc34e3e020f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8ac1ae431c194af784249f67e48c1bac.png
[86aef7156e9e4b33b5266cd1bf838423.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/fe561988f53040109721d9a6c38f3420.png
[6f91c47b76384ff895815c2477ae6797.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ac952ec3505049aca0f135cc40c91a4e.png
[6b913d07dd564358ae4222c9ae54b765.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/83e1cc255dd04c49a68c9dedd0df087d.png
[6c5d3440858443eca25574595d0f43f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/26525314da6b4029981d5c6f5384ff7c.png
[0d7489b5e4b648d88e4bad156fef4fc0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1959866c02684e11a511ffea701fb10e.png
[3b3a35ecf524474c9a0dd70f842a69ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/837485f80033464a8beef7072e7081aa.png
[e055432bda7f4032bb7629e3ba4e086f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e1ab0ca3af964ad39cb422575afb0dd3.png
[f7015e3fa1b94d29a0f88a72283a7c9d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/bec89d7b1a494c01b8ea9b756a453dc3.png
[0a178dc90ca64927b7ef2fa3e2f2784c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b55db327fe24439faf994f0ddcb8b93f.png
[6d2bdc770724426a9cedeb56313f5e79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9ca29bbff2274b77abadea079ee57f9f.png
[9f4f41c502d643c9b069c6d05d9f3afe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0282a2cfdba34b9cb5c8a5d4dad55026.png
[32d002e3f8f64258be6b9203cf6b6de6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6dd7ce22ccb54bc79f568443b00440d5.png
[c1698173475645f882c427aac6501db7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8494731824994861bab91ed08973dd6a.png
[cd7e650716224ae589a8da451b988e6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/053aeb0f01e54004abc3c50c1b9b648d.png
[0c97c38ca659496ea3ed50a004de6b91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e1a09e5a77cb49d6a639034f056054ce.png
[b4aa87eb587c4503b67b62e2c70d80eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/3f0663f94a3944009a6e9eb5d44a2042.png
[0b96069fde2f491b83ade87553bd46fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/59b54624d0bd44b194bc089e9471a214.png
[35267e61cdad49f28353f327722eb28b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a04ffc1959924d999802acd7697d95f4.png
[80a7826e5d5b41e390ba18e0abeb2273.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/46c9b8b116e44d9fb740b26b55aee6a3.png