minio服务使用(本地存储快速搭建)

MinIO 是一个高性能的对象存储服务器，完全兼容 Amazon S3 API，可以在私有云、公有云和混合云环境中部署。以下是如何使用 MinIO 服务实现文件上传、下载和管理功能的详细步骤。

1. 安装 MinIO

使用 Docker 安装 MinIO

docker run -p 9000:9000 --name minio \
  -e "MINIO_ROOT_USER=youraccesskey" \
  -e "MINIO_ROOT_PASSWORD=yoursecretkey" \
  -v /path/to/data:/data \
  minio/minio server /data

• youraccesskey 和 yoursecretkey 分别为你的访问密钥和密钥。
• /path/to/data 为数据存储路径。

  使用二进制文件安装 MinIO

  你也可以直接下载 MinIO 的二进制文件进行安装：

• # 下载 MinIO 二进制文件
  wget https://dl.min.io/server/minio/release/linux-amd64/minio
  
  # 赋予可执行权限
  chmod +x minio
  
  # 启动 MinIO
  ./minio server /path/to/data
  

  2. 配置客户端（Java 示例）

  在 Spring Boot 项目中使用 MinIO，需要添加 MinIO 的依赖：

  xml
  <dependency>
      <groupId>io.minio</groupId>
      <artifactId>minio</artifactId>
      <version>8.3.4</version>
  </dependency>

  然后配置一个简单的 MinIO 客户端：

• import io.minio.MinioClient;
  import io.minio.PutObjectArgs;
  import io.minio.GetObjectArgs;
  import io.minio.RemoveObjectArgs;
  import io.minio.errors.MinioException;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.stereotype.Service;
  
  import java.io.InputStream;
  
  @Service
  public class MinioService {
  
      private final MinioClient minioClient;
  
      public MinioService(@Value("${minio.url}") String url,
                          @Value("${minio.access-key}") String accessKey,
                          @Value("${minio.secret-key}") String secretKey) {
          this.minioClient = MinioClient.builder()
                  .endpoint(url)
                  .credentials(accessKey, secretKey)
                  .build();
      }
  
      public void uploadFile(String bucketName, String objectName, InputStream stream, String contentType) throws Exception {
          boolean isExist = minioClient.bucketExists(bucketName);
          if (!isExist) {
              minioClient.makeBucket(bucketName);
          }
          
          minioClient.putObject(
                  PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                          stream, stream.available(), -1)
                      .contentType(contentType)
                      .build());
      }
  
      public InputStream downloadFile(String bucketName, String objectName) throws Exception {
          return minioClient.getObject(
                  GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
      }
  
      public void deleteFile(String bucketName, String objectName) throws Exception {
          minioClient.removeObject(
                  RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
      }
  }
  
  
  
  
  

  3. 创建控制器处理文件上传、下载和删除

• import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.http.MediaType;
  import org.springframework.web.bind.annotation.*;
  import org.springframework.web.multipart.MultipartFile;
  
  import javax.servlet.http.HttpServletResponse;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  @RestController
  @RequestMapping("/files")
  public class FileController {
  
      @Autowired
      private MinioService minioService;
  
      @PostMapping(value = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
      public String uploadFile(@RequestParam("file") MultipartFile file) {
          try {
              String bucketName = "my-bucket";
              String objectName = file.getOriginalFilename();
              minioService.uploadFile(bucketName, objectName, file.getInputStream(), file.getContentType());
  
              return "File uploaded successfully.";
          } catch (Exception e) {
              e.printStackTrace();
              return "File upload failed!";
          }
      }
  
      @GetMapping("/download")
      public void downloadFile(@RequestParam String bucketName, @RequestParam String objectName, HttpServletResponse response) {
          try (InputStream inputStream = minioService.downloadFile(bucketName, objectName)) {
              response.setContentType("application/octet-stream");
              response.setHeader("Content-Disposition", "attachment; filename=\"" + objectName + "\"");
  
              OutputStream outputStream = response.getOutputStream();
              byte[] buffer = new byte[1024];
              int bytesRead;
              while ((bytesRead = inputStream.read(buffer)) != -1) {
                  outputStream.write(buffer, 0, bytesRead);
              }
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      @DeleteMapping("/delete")
      public String deleteFile(@RequestParam String bucketName, @RequestParam String objectName) {
          try {
              minioService.deleteFile(bucketName, objectName);
              return "File deleted successfully.";
          } catch (Exception e) {
              e.printStackTrace();
              return "File deletion failed!";
          }
      }
  }
  

  总结

  通过以上步骤，你可以轻松地搭建一个基于 MinIO 的对象存储服务，实现文件的上传、下载和删除等功能。这种方法不仅可以用于本地开发测试，还可以扩展到生产环境中的私有云和公有云部署。

• nohup ./minio &
  
  nohup  /Users/ops minio server  
  /Users/ops/data > /Users/ops/minio.log 2>&1 &
  
  重启minio总结：
  把数据复制备份，删除后重启，然后资源内容复制回来
  pgrep minio
  kill -9 23106
  cp -r /Users/ops/dev/data/* /Users/ops/dev/data_new
  rm  -r /Users/ops/dev/data
  nohup  /Users/ops/dev/minio server  /Users/ops/dev/data > /Users/ops/dev/minio.log 2>&1 &
  
  chmod +x minio
  export MINIO_ACCESS_KEY=minioadmin121
  export MINIO_SECRET_KEY=minioadmin121
  
  cp -r /Users/ops/dev/data_new/* /Users/ops/dev/data
  
  sudo chown -R ops /data && sudo chmod u+rxw /data
  
  
  日常清理
  
  find /data/base/1501460882306109441 -mtime +21 -name "*.*" -exec rm -Rf {} \;
  
  find ./logs -mtime +61 -name "*.*" -exec rm -Rf {} \;
  find ./logs -mtime +61 -name "*.*" -exec rm -Rf {} \;
  
  
  prometheus机器监控安装
  [root@localhost ~]# wget https://github.com/prometheus/prometheus/releases/download/v2.28.1/prometheus-2.28.1.linux-amd64.tar.gz
  
  
  wget https://github.com/prometheus/node_exporter/releases/download/v1.2.2/node_exporter-1.2.2.linux-amd64.tar.gz --no-check-certificate
  tar xvfz node_exporter-1.2.2.linux-amd64.tar.gz
  cd node_exporter-1.2.2.linux-amd64
  nohup ./node_exporter  &
  
  136机器：
  /Users/ops/dev/prometheus-2.28.1.linux-amd64
  vim prometheus.yml
  添加节点：
  http://192.168.49.157:9100/metrics
  
  ./promtool check config prometheus.yml
  
  pgrep prometheus
  kill -hup PID
  kill -hup 12099
  nohup ./node_exporter  &
  

  #coding:utf-8
  from minio import Minio
  import os
  import sys
  from minio.error import *
  
  minioClient = Minio('192.168..157:9000',
                      access_key='minioadmin233',
                      secret_key='minioadmin343',
                      secure=False)
  
  
  def uploadDir(output_path, bucket, upload_dir_name):
      for root, dirs, files in os.walk(output_path):
          for file in files:
              try:
                  path = os.path.join(root, file)
                  print(path)
                  minioClient.fput_object(bucket, upload_dir_name + "/" + path, path)
              except:
                  print('upload error')
  
  
  def uploadFile(filePath, bucket, upload_dir_name):
      if os.path.exists(filePath):
          try:
              with open(filePath, 'rb') as file_data:
                  file_stat = os.stat(filePath)
                  minioClient.put_object(bucket, upload_dir_name + "/" + filePath,
                                         file_data, file_stat.st_size)
          except:
              print('upload error')
      else:
          print(filePath + " file not found")
  
  
  args = sys.argv
  
  if args[1].endswith("/"):
      uploadDir(args[1], args[2], args[3])
  else:
      uploadFile(args[1], args[2], args[3])
  

     private Line pushWithoutClean(Collection<String> outputPaths) {
  
          return new Line(dir() +
                  "curl " + MinioUtil.UPLOAD_SCRIPT_URL2 + "> upload2.py \n" +
                  outputPaths.stream()
                          .map(outputPath -> String.format("python3 upload2.py %1$s %2$s ${%3$s}/${%4$s} \n",
                                  outputPath, MinioUtil.BUCKET, Parameter.type.SYS_PIPELINE_HISTORY_ID.name(), Parameter.type.SYS_JOB_ID.name()
                          ))
                          .collect(Collectors.joining())
                  + "echo 上传产物执行成功 \n"
  
          ).sh();
      }
  
  minio:
    endpoint: http://xxxx0:9000/
    host: 192.168.xxx:9000
    accessKey: minioxx
    accessSecret: minioaxxx
    bucket: base
    path: /Users/ops/dev/data/