Detaillierte Erläuterung des Prozesses zur Verwendung von Docker zum Erstellen von Minio und Java SDK

Docker-Ausführung \
  -p 9000:9000 \
  -p 9001:9001 \
  minio/minio server /data --console-address ":9001"

Version: '3'
Leistungen:
  Minio:
    Bild: minio/minio
    Hostname: "minio"
    Häfen:
      9000: 9000 
      - 9001:9001
    Umfeld:
      MINIO_ACCESS_KEY: admin #Konsolen-Anmeldekonto MINIO_SECRET_KEY: 12345678 #Konsolen-Anmeldekennwort volumes:
      - ./data:/data #Speicherpfad - ./config:/root/.minio/ #Konfigurationsdatei Befehl: server --console-address ':9001' /data  
    privilegiert: wahr
    Neustart: immer

docker-compser up -d

Version: '3'

# startet 4 Docker-Container, die Minio-Serverinstanzen ausführen.
# mit Nginx Reverse Proxy, Lastenausgleich, können Sie zugreifen
# es über Port 9000.
Leistungen:
  minio1:
    Bild: minio/minio
    Hostname: minio1
    Bände:
      - ./data1-1:/data1
      - ./Daten1-2:/Daten2
    exponieren:
      - "9000"
      - "9001"
    Umfeld:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    Befehl: server --console-address ":9001" http://minio{1...4}/data{1...2}
    Gesundheitscheck:
      Test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      Intervall: 30s
      Zeitüberschreitung: 20 s
      Wiederholungsversuche: 3

  minio2:
    Bild: minio/minio
    Hostname: minio2
    Bände:
      - ./data2-1:/data1
      - ./data2-2:/data2
    exponieren:
      - "9000"
      - "9001"
    Umfeld:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    Befehl: server --console-address ":9001" http://minio{1...4}/data{1...2}
    Gesundheitscheck:
      Test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      Intervall: 30s
      Zeitüberschreitung: 20 s
      Wiederholungsversuche: 3

  minio3:
    Bild: minio/minio
    Hostname: minio3
    Bände:
      - ./data3-1:/data1
      - ./data3-2:/data2
    exponieren:
      - "9000"
      - "9001"
    Umfeld:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    Befehl: server --console-address ":9001" http://minio{1...4}/data{1...2}
    Gesundheitscheck:
      Test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      Intervall: 30s
      Zeitüberschreitung: 20 s
      Wiederholungsversuche: 3

  minio4:
    Bild: minio/minio
    Hostname: minio4
    Bände:
      - ./data4-1:/data1
      - ./data4-2:/data2
    exponieren:
      - "9000"
      - "9001"
    Umfeld:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    Befehl: server --console-address ":9001" http://minio{1...4}/data{1...2}
    Gesundheitscheck:
      Test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      Intervall: 30s
      Zeitüberschreitung: 20 s
      Wiederholungsversuche: 3

  nginx:
    Bild: nginx:1.19.2-alpine
    Hostname: nginx
    Bände:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    Häfen:
      - "9000:9000"
      - "9001:9001"
    hängt ab von:
      -minio1
      - minio2
      - minio3
      - minio4

Benutzer nginx;
Arbeiterprozesse automatisch;

Fehlerprotokoll /var/log/nginx/error.log warnen;
pid /var/run/nginx.pid;

Ereignisse {
    Arbeiterverbindungen 4096;
}

http {
    /etc/nginx/mime.types einschließen;
    Standardtyp Anwendung/Oktett-Stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    Zugriffsprotokoll /var/log/nginx/access.log Haupt;
    sendfile an;
    KeepAlive-Timeout 65;

    # /etc/nginx/conf.d/*.conf einschließen;

    Upstream-Minio {
        Server Minio1:9000;
        Server Minio2:9000;
        Server Minio3:9000;
        Server Minio4:9000;
    }

    Upstream-Konsole {
        ip_hash;
        Server Minio1:9001;
        Server Minio2:9001;
        Server Minio3:9001;
        Server Minio4:9001;
    }

    Server {
        hör zu 9000;
        hören Sie [::]:9000;
        Servername localhost;

        # Um Sonderzeichen in Headern zuzulassen
        ignore_invalid_headers aus;
        # Erlaubt das Hochladen von Dateien jeder Größe.
        # Auf einen Wert wie 1000m einstellen, um die Dateigröße auf einen bestimmten Wert zu beschränken
        Client_max_Körpergröße 0;
        # So deaktivieren Sie die Pufferung
        Proxy-Pufferung aus;

        Standort / {
            Proxy_set_header Host $http_host;
            Proxy_Set_Header X-Real-IP $Remote_Addr;
            proxy_set_header X-Weitergeleitet-Für $proxy_add_x_forwarded_for;
            Proxy_set_header X-Weitergeleitet-Proto $scheme;

            Proxy_Verbindungstimeout 300;
            # Standard ist HTTP/1, Keepalive ist nur in HTTP/1.1 aktiviert
            Proxy_http_Version 1.1;
            proxy_set_header Verbindung "";
            chunked_transfer_encoding aus;

            Proxy-Passwort http://minio;
        }
    }

    Server {
        hören Sie 9001;
        hören [::]:9001;
        Servername localhost;

        # Um Sonderzeichen in Headern zuzulassen
        ignore_invalid_headers aus;
        # Erlaubt das Hochladen von Dateien jeder Größe.
        # Auf einen Wert wie 1000m einstellen, um die Dateigröße auf einen bestimmten Wert zu beschränken
        Client_max_Körpergröße 0;
        # So deaktivieren Sie die Pufferung
        Proxy-Pufferung aus;

        Standort / {
            Proxy_set_header Host $http_host;
            Proxy_Set_Header X-Real-IP $Remote_Addr;
            proxy_set_header X-Weitergeleitet-Für $proxy_add_x_forwarded_for;
            Proxy_set_header X-Weitergeleitet-Proto $scheme;
            Proxy_set_header X-NginX-Proxy wahr;

            # Dies ist notwendig, um die richtige IP zum Hashen zu übergeben
            real_ip_header X-Real-IP;

            Proxy_Verbindungstimeout 300;
            
            # Um Websocket zu unterstützen
            Proxy_http_Version 1.1;
            Proxy_Set_Header-Upgrade $http_upgrade;
            proxy_set_header Verbindung "Upgrade";
            
            chunked_transfer_encoding aus;

            Proxy-Passwort http://Konsole;
        }
    }
}

docker-compser up -d

<Abhängigkeit>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.3.0</version>
</Abhängigkeit>

Paket com.test.minio;

importiere javax.servlet.http.HttpServletResponse;
importiere java.io.InputStream;

/**
 * Speicherdateien *
 * @Autor jiangyulu
 */
öffentliche Schnittstelle FileService {
    /**
     * Dateien hochladen *
     * @param inputStream EingabeStream
     * @param fdsDateiname fdsDateiname
     * @param img img
     * @return UUID
     */
    String-Upload (InputStream-InputStream, String fdsFileName, boolean img);


    /**
     * Datei herunterladen *
     * @param fdsFileName der Name der Datei im FDS * @param fileName der neu zugewiesene Dateiname * @param response response
     */
    void download(String fdsFileName, String Dateiname, HttpServletResponse Antwort);

    /**
     * löschen*
     * @param fdsDateiname fdsDateiname
     */
    void delete(String fdsFileName);
}

Paket com.test.minio.impl;


importiere com.test.minio.FileService;
importiere io.minio.*;
importiere lombok.extern.slf4j.Slf4j;
importiere org.apache.commons.io.IOUtils;
importiere org.springframework.beans.factory.annotation.Autowired;
importiere org.springframework.beans.factory.annotation.Value;
importiere org.springframework.stereotype.Service;

importiere javax.servlet.http.HttpServletResponse;
importiere java.io.IOException;
importiere java.io.InputStream;
importiere java.net.URLEncoder;
importiere java.util.UUID;


/**
 * @Autor jaingyulu
 */
@Slf4j
@Dienst("minio")
öffentliche Klasse MinioFileServiceImpl implementiert FileService {

    @Wert("{$minio.endpoint}")
    privater String-Endpunkt;

    @Value("{$minio.accessKeyId}")
    private Zeichenfolge accessKeyId;

    @Wert("{$minio.accessKeySecret}")
    privater String accessKeySecret;

    @Wert("{$minio.bucketName}")
    privater String-BucketName;


    @Überschreiben
    öffentlicher String-Upload (InputStream inputStream, String fdsFileName, boolean img) {

        versuchen {
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(Endpunkt)
                            .credentials(Zugriffsschlüssel-ID, Zugriffsschlüssel-Geheimnis)
                            .bauen();

            Boolescher Wert gefunden =
                    minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            wenn (gefunden) {
                log.info("Bucket existiert bereits.");
            } anders {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }

            wenn (!img) {
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(Bucketname)
                                .Objekt(fdsDateiname)
                                .stream(Eingabestream, Eingabestream.verfügbar(), -1)
                                .bauen());
            } anders {
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(Bucketname)
                                .Objekt(fdsDateiname)
                                .stream(Eingabestream, Eingabestream.verfügbar(), -1)
                                .contentType("bild/jpg")
                                .bauen());
            }

            inputStream.schließen();
        } Fang (Ausnahme e) {
            e.printStackTrace();
        }
        gibt UUID.randomUUID().toString() zurück;
    }

    @Überschreiben
    public void download(String fdsFileName, String dateiName, HttpServletResponse antwort) {
        InputStream in = null;
        versuchen {
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(Endpunkt)
                            .credentials(Zugriffsschlüssel-ID, Zugriffsschlüssel-Geheimnis)
                            .bauen();
            StatObjectResponse objectStat = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fdsFileName).build());
            Antwort.SetContentType(ObjektStat.ContentType());
            //response.setContentType(Medientyp.APPLICATION_OCTET_STREAM_VALUE);
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fdsFileName).build());
            IOUtils.copy(in, response.getOutputStream());
        } Fang (Ausnahme e) {
            log.error(e.getMessage());
        Endlich
            wenn (in != null) {
                versuchen {
                    in.schließen();
                } Fang (IOException e) {
                    log.error(e.getMessage());
                }
            }
        }
    }

    @Überschreiben
    öffentliche void löschen(String fdsFileName) {
        versuchen {
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(Endpunkt)
                            .credentials(Zugriffsschlüssel-ID, Zugriffsschlüssel-Geheimnis)
                            .bauen();
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fdsFileName).build());
        } Fang (Ausnahme e) {
            e.printStackTrace();
        }
    }
}