Immich Docker Compose (Wie es für Entwickler funktioniert)

Immich Docker ist die Einrichtung von Immich, einer Open-Source, selbst gehosteten Foto- und Videosicherungs-Lösung innerhalb eines Docker-Containers. Docker ist eine leichtgewichtige und weit verbreitete Plattform zur Entwicklung, Verteilung und Ausführung von Anwendungen sowohl auf physischen als auch auf virtualisierten Servern. Dank Docker kann Immich auf den meisten Systemen einfach installiert werden und ohne komplexe Konfigurationen und Abhängigkeitsprobleme betriebsbereit sein. Dieser containerisierte Ansatz für Immich erleichtert die sichere Speicherung, Sicherung und Verwaltung von Mediendateien.

Darüber hinaus sorgt Docker für Konsistenz in verschiedenen Umgebungen und ermöglicht es den Benutzern, ihre Immich-Instanz mit minimalem Aufwand einfach zu verschieben oder zu skalieren. Dies bedeutet, dass Immich Docker die effizientesten und nahtlosesten Methoden bietet, die jeder, der eine selbst gehostete Mediensicherungslösung erstellen möchte, mit Docker umgesetzt hätte.

Funktionen von Immich

Immich Docker installiert mehrere out-of-the-box-Funktionen, die die Bereitstellung und Verwaltung der Immich-Foto- und Videosicherungs-Lösung erheblich erleichtern. Dies macht es wiederum für diejenigen sehr attraktiv, die ihre Mediendateien sicher und effektiv selbst hosten möchten. Zu den Hauptfunktionen von Immich Docker gehören:

Leicht zu implementieren: Immich Docker hat standardisierte Docker-Bilder bereitgestellt, die die Bereitstellung erleichtern. Darüber hinaus hält es die Benutzer von abhängigen Paketen und komplizierten Konfigurationen fern; daher können Benutzer Immich sofort bereitstellen.

Plattformunabhängig: Jeder Docker-Container stellt sicher, dass das Gerät auf den meisten Systemen mit Docker unter Linux, macOS und Windows OS ausgeführt werden kann. Das macht das Projekt über verschiedene Umgebungen hinweg sehr portabel.

Isolation: Darüber hinaus werden Immich-Dienste, die im Docker-Container ausgeführt werden, von anderen Anwendungen und Diensten auf dem Hostsystem isoliert. Dies würde Konflikte, Kompatibilitätsprobleme reduzieren und die Betriebsumgebung für Immich wesentlich stabiler machen.

Insgesamt ist Skalierbarkeit sehr einfach, vor allem wenn viele Medienmengen mit der Bereitstellung für Immich Docker-Benutzer verbunden sind. Da Docker von Natur aus skalierbar ist, kann das Upgrade oder die Erhöhung der Ressourcen wirklich einfach sein.

Sicherheit: Der Grund dafür ist, dass Docker-Container eine Schicht der Sandboxing vom zugrunde liegenden System einführen, die zusätzliche Sicherheit bietet. Darüber hinaus bietet das selbstgehostete Immich die Möglichkeit, Benutzern die vollständige Kontrolle über ihre Daten und den Speicherort der Datenbank zu ermöglichen und somit die Privatsphäre und Sicherheit zu erhöhen.

Automatische Updates: Container sind relativ leicht, einfach zu aktualisieren und wartungsfreundlich; daher können Docker-Benutzer mit wenigen oder gar keinen Unterbrechungen zu neueren Funktionen mit den neuesten Sicherheitspatches wechseln.

Backup und Wiederherstellung: Immich Docker erstellt eine einzige Quelle der Wahrheit, wenn es um das Sichern von Medien geht, sodass man Fotos und Videos wiederherstellen kann. Docker stellt sicher, dass alle Einsätze über die gleichen Daten verfügen.

Anpassbar: Da Immich selbstgehostet ist, können Benutzer es an ihre Anforderungen anpassen, um eine effektivere Integration mit anderen Diensten und Skalierungsoptionen zu ermöglichen.

Community-Support: Es ist ein Open-Source-Projekt; daher bietet die Community kontinuierliche Verbesserungen, Fehlerbereinigungen und Unterstützung für ihre Benutzer.

Installieren von Immich Docker

Voraussetzungen

• Installieren Sie Docker und Docker Compose auf Ihrem System.
• Stellen Sie sicher, dass Ihr Rechner über ausreichende Ressourcen verfügt: Empfohlen werden 4 GB oder mehr RAM.

Immich-Repository klonen

Laden Sie die docker-compose-Datei von GitHub herunter.

git clone https://github.com/immich-app/immich.git
cd immich

git clone https://github.com/immich-app/immich.git
cd immich

Umgebungsvariablen konfigurieren

Um es zu ändern, erstellen Sie eine Kopie der Beispieldatei für die Umgebung und der docker-compose.yml Dateien:

cp .env.example .env

cp .env.example .env

Öffnen Sie die .env Datei und richten Sie Variablen ein (wie Port, Speicherort und Datenbankanmeldedaten). In den meisten Konfigurationen sind die Standardeinstellungen ausreichend.

# You can find documentation for all the supported env variables at https://immich.app/docs/install/environment-variables
# The location where your uploaded files are stored
UPLOAD_LOCATION=./library
# The location where your database files are stored
DB_DATA_LOCATION=./postgres
# To set a timezone, uncomment the next line and change Etc/UTC to a TZ identifier from this list: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List
# TZ=Etc/UTC
# The Immich version to use. You can pin this to a specific version like "v1.71.0"
IMMICH_VERSION=release
# Connection secret for postgres. You should change it to a random password
# Please use only the characters `A-Za-z0-9`, without special characters or spaces
DB_PASSWORD=postgres
# The values below this line do not need to be changed
###################################################################################
DB_USERNAME=postgres
DB_DATABASE_NAME=postgres

# You can find documentation for all the supported env variables at https://immich.app/docs/install/environment-variables
# The location where your uploaded files are stored
UPLOAD_LOCATION=./library
# The location where your database files are stored
DB_DATA_LOCATION=./postgres
# To set a timezone, uncomment the next line and change Etc/UTC to a TZ identifier from this list: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List
# TZ=Etc/UTC
# The Immich version to use. You can pin this to a specific version like "v1.71.0"
IMMICH_VERSION=release
# Connection secret for postgres. You should change it to a random password
# Please use only the characters `A-Za-z0-9`, without special characters or spaces
DB_PASSWORD=postgres
# The values below this line do not need to be changed
###################################################################################
DB_USERNAME=postgres
DB_DATABASE_NAME=postgres

Immich starten

Verwenden Sie Docker Compose, um den Immich-Server zu starten:

docker-compose up -d

docker-compose up -d

Dieser Befehl lädt alle erforderlichen Bilder und startet die notwendigen Container:

• Backend
• Frontend
• Datenbank (PostgreSQL)
• Redis (für Caching)
• Machine-Learning-Modelle (für Funktionen wie Gesichtserkennung)

Greifen Sie auf Immich über Ihren Browser zu

Wenn alle Dateien heruntergeladen sind, stellen Sie sicher, dass Sie die Umgebung aktualisieren. Sobald die Container laufen, öffnen Sie den Browser und geben Sie die untenstehende URL ein.

http://localhost:2283

http://localhost:2283

Ersetzen Sie 2283 mit dem angegebenen Port, wenn Sie den Port in der .env Datei geändert haben.

Erstellen oder melden Sie sich bei einem Immich-Konto an

Erster Gebrauch: Wenn Sie die Immich-URL das erste Mal aufrufen, wird die Web-Oberfläche angezeigt.

Sie werden aufgefordert, ein Administratorkonto zu erstellen.

Geben Sie die erforderlichen Informationen ein und Immich führt Sie durch die Einrichtung.

Einrichten von Immich in der Web-Oberfläche

• Einstellungen: Greifen Sie über das Admin-Dashboard auf Immichs detaillierte Einstellungen zu.
• Mediendateien hochladen: Laden Sie jetzt einige Fotos/Videos zum Testen hoch.
• Funktionen erkunden: Nutzen Sie andere Funktionen wie Gesichtserkennung, Objekttagging und mehr.

Nach der Einrichtung können Sie direkt über Ihren Browser auf Immich zugreifen und mit der Verwaltung Ihrer Foto- und Videobibliothek beginnen.

Was ist IronSecureDoc?

IronSecureDoc ist ein fortgeschrittenes Werkzeug für Dokumentenmanagement und Sicherheit, das robuste Verschlüsselung, erweiterte PDF-Manipulationen und digitale Signaturen bietet. Es bietet Unternehmen und Entwicklern Dokumentenvertraulichkeit und -integrität sowie einfachen Zugang und vereinfacht somit die Verarbeitung von PDF-Dokumenten. Es kann auch als aggressive PDF-API bezeichnet werden, wenn seine Funktionen es Entwicklern ermöglichen, PDF-Dateien und Dokumente programmatisch zu erstellen, hochzuladen, zu manipulieren und zu sichern.

Darüber hinaus ist IronPDF eine PDF-API, die die Erstellung von PDFs aus jeder Dateneingabe, das Hinzufügen und Bearbeiten von Inhalten mit Parametern wie Text, Bildern und Metadaten ermöglicht. Dies umfasst die Möglichkeit, mehrere PDFs zu einem neuen Dokument zusammenzufügen, Dokumente zu teilen und sogar Kommentare, Hervorhebungen oder Wasserzeichen hinzuzufügen.

Zu seinen Sicherheitsfunktionen gehören Passwortschutz, AES-Verschlüsselung und zertifikatsbasierte Zugriffskontrollen, die alle sensiblen Informationen und Daten sichern. Darüber hinaus ermöglicht es das digitale Signieren zur Authentifizierung von Dokumenten und die Nichtabstreitbarkeit, eine sehr wichtige Funktion in Branchen wie der Finanz-, Medizin- und Rechtsbranche. Die Prüfprotokollfunktion ermöglicht es, alle auf den Dokumenten durchgeführten Aktivitäten zu verfolgen, um bessere Compliance und Rechenschaftspflicht zu gewährleisten.

Installieren und starten Sie IronSecureDoc

Laden Sie das Docker-Image von IronSecureDoc aus dem unten stehenden Repository herunter, indem Sie diesen Befehl an der Eingabeaufforderung oder in einem offenen Terminalfenster ausführen.

docker pull ironsoftwareofficial/ironsecuredoc

docker pull ironsoftwareofficial/ironsecuredoc

Verwenden Sie einen anderen Befehl, um IronSecureDoc, einen Betriebssystemcontainer, zu starten.

docker container run --rm -p 8080:8080 -e IronSecureDoc_LicenseKey=<IRONSECUREDOC_LICENSE_KEY> -e ENVIRONMENT=Development -e HTTP_PORTS=8080 ironsoftwareofficial/ironsecuredoc:latest

docker container run --rm -p 8080:8080 -e IronSecureDoc_LicenseKey=<IRONSECUREDOC_LICENSE_KEY> -e ENVIRONMENT=Development -e HTTP_PORTS=8080 ironsoftwareofficial/ironsecuredoc:latest

Der oben genannte Docker-Run-Befehl startet eine Container-Instanz von IronSecureDoc.

Signatur von Immich herunterladen und das signierte PDF-Dokument hinzufügen

Die REST-API in IronSecureDoc ist eine moderne Webschnittstelle, die es Entwicklern ermöglicht, sicher mit den Dokumentenmanagement- und PDF-Verarbeitungsfunktionen der Software zu interagieren. Mithilfe von RESTful-Grundsätzen ermöglicht es diese API Benutzern, die Integration der Funktionen von IronSecureDoc in ihre benutzerdefinierten Anwendungen unabhängig vom verwendeten Technologiestapel einfach zu verstehen und zu standardisieren.

Bild von Immich herunterladen

Unten finden Sie eine Beispieldatei mit Signatur, die auf den Immich hochgeladen wurde.

using System;
using System.Net.Http;
using System.Threading.Tasks;

class ImmichIntegration
{
    private static readonly HttpClient client = new HttpClient();

    public async Task<string> GetImageFromImmich(string imageId, string immichBaseUrl, string apiKey)
    {
        // Add authorization header
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");

        // Make a GET request to the Immich server
        var response = await client.GetAsync($"{immichBaseUrl}/api/media/{imageId}");
        response.EnsureSuccessStatusCode();

        // Read and return the response data
        var responseData = await response.Content.ReadAsStringAsync();
        Console.WriteLine("Image data retrieved successfully!");
        return responseData; // Contains image metadata or downloadable URL
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

class ImmichIntegration
{
    private static readonly HttpClient client = new HttpClient();

    public async Task<string> GetImageFromImmich(string imageId, string immichBaseUrl, string apiKey)
    {
        // Add authorization header
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");

        // Make a GET request to the Immich server
        var response = await client.GetAsync($"{immichBaseUrl}/api/media/{imageId}");
        response.EnsureSuccessStatusCode();

        // Read and return the response data
        var responseData = await response.Content.ReadAsStringAsync();
        Console.WriteLine("Image data retrieved successfully!");
        return responseData; // Contains image metadata or downloadable URL
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

Friend Class ImmichIntegration
	Private Shared ReadOnly client As New HttpClient()

	Public Async Function GetImageFromImmich(ByVal imageId As String, ByVal immichBaseUrl As String, ByVal apiKey As String) As Task(Of String)
		' Add authorization header
		client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}")

		' Make a GET request to the Immich server
		Dim response = Await client.GetAsync($"{immichBaseUrl}/api/media/{imageId}")
		response.EnsureSuccessStatusCode()

		' Read and return the response data
		Dim responseData = Await response.Content.ReadAsStringAsync()
		Console.WriteLine("Image data retrieved successfully!")
		Return responseData ' Contains image metadata or downloadable URL
	End Function
End Class

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

Friend Class ImmichIntegration
	Private Shared ReadOnly client As New HttpClient()

	Public Async Function GetImageFromImmich(ByVal imageId As String, ByVal immichBaseUrl As String, ByVal apiKey As String) As Task(Of String)
		' Add authorization header
		client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}")

		' Make a GET request to the Immich server
		Dim response = Await client.GetAsync($"{immichBaseUrl}/api/media/{imageId}")
		response.EnsureSuccessStatusCode()

		' Read and return the response data
		Dim responseData = Await response.Content.ReadAsStringAsync()
		Console.WriteLine("Image data retrieved successfully!")
		Return responseData ' Contains image metadata or downloadable URL
	End Function
End Class

Der Code ermöglicht es uns, das Bild vom Immich-Server herunterzuladen. Stellen Sie sicher, dass Sie einen API-Schlüssel vom Immich-Server generieren.

Bild zu IronSecureDoc hochladen

using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class IronSecureDocIntegration
{
    private static readonly HttpClient client = new HttpClient();

    public async Task UploadImageTo IronSecureDoc(string imagePath)
    {
        var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:8080/v1/document-services/pdfs/sign?sign_specific_page=0&signature_image_x=100&signature_image_y=150&signature_image_w=300&signature_image_h=400&certificate_password=********&certificate_permissions=1");
        
        // Set headers to simulate a browser request
        request.Headers.Add("sec-ch-ua-platform", "\"Windows\"");
        request.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36");
        request.Headers.Add("accept", "*/*");
        request.Headers.Add("sec-ch-ua", "\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"");
        request.Headers.Add("sec-ch-ua-mobile", "?0");
        request.Headers.Add("Sec-Fetch-Site", "same-origin");
        request.Headers.Add("Sec-Fetch-Mode", "cors");
        request.Headers.Add("Sec-Fetch-Dest", "empty");
        request.Headers.Add("host", "localhost");
        
        // Create and add image and certificate files to the request content
        var content = new MultipartFormDataContent();
        content.Add(new StreamContent(File.OpenRead(imagePath)), "signature_image_file", Path.GetFileName(imagePath));
        content.Add(new StreamContent(File.OpenRead("IronsecureDoc.pfx")), "certificate_file", "IronsecureDoc.pfx");
        content.Add(new StreamContent(File.OpenRead("Input.pdf")), "pdf_file", "Input.pdf");
        request.Content = content;

        // Send the request and ensure success
        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        // Output the result of the PDF signing
        Console.WriteLine(await response.Content.ReadAsStringAsync());
    }
}

using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class IronSecureDocIntegration
{
    private static readonly HttpClient client = new HttpClient();

    public async Task UploadImageTo IronSecureDoc(string imagePath)
    {
        var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:8080/v1/document-services/pdfs/sign?sign_specific_page=0&signature_image_x=100&signature_image_y=150&signature_image_w=300&signature_image_h=400&certificate_password=********&certificate_permissions=1");
        
        // Set headers to simulate a browser request
        request.Headers.Add("sec-ch-ua-platform", "\"Windows\"");
        request.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36");
        request.Headers.Add("accept", "*/*");
        request.Headers.Add("sec-ch-ua", "\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"");
        request.Headers.Add("sec-ch-ua-mobile", "?0");
        request.Headers.Add("Sec-Fetch-Site", "same-origin");
        request.Headers.Add("Sec-Fetch-Mode", "cors");
        request.Headers.Add("Sec-Fetch-Dest", "empty");
        request.Headers.Add("host", "localhost");
        
        // Create and add image and certificate files to the request content
        var content = new MultipartFormDataContent();
        content.Add(new StreamContent(File.OpenRead(imagePath)), "signature_image_file", Path.GetFileName(imagePath));
        content.Add(new StreamContent(File.OpenRead("IronsecureDoc.pfx")), "certificate_file", "IronsecureDoc.pfx");
        content.Add(new StreamContent(File.OpenRead("Input.pdf")), "pdf_file", "Input.pdf");
        request.Content = content;

        // Send the request and ensure success
        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        // Output the result of the PDF signing
        Console.WriteLine(await response.Content.ReadAsStringAsync());
    }
}

Immich und IronSecureDoc aufrufen

Der folgende Code hilft uns bei der Integration.

using System.Threading.Tasks;

class Integration
{
    public async Task IntegrateImmichWith IronSecureDoc(string immichImageId, string immichBaseUrl, string immichApiKey, string imagePath)
    {
        var immich = new ImmichIntegration();
        var ironSecureDoc = new IronSecureDocIntegration();

        // Step 1: Fetch image metadata or download from Immich
        string imageData = await immich.GetImageFromImmich(immichImageId, immichBaseUrl, immichApiKey);

        // Step 2: Optionally download the image locally using imageData URL (not shown here)
        // Assume imagePath is the downloaded image file path

        // Step 3: Upload the image to IronSecureDoc
        await ironSecureDoc.UploadImageTo IronSecureDoc(imagePath);
    }
}

using System.Threading.Tasks;

class Integration
{
    public async Task IntegrateImmichWith IronSecureDoc(string immichImageId, string immichBaseUrl, string immichApiKey, string imagePath)
    {
        var immich = new ImmichIntegration();
        var ironSecureDoc = new IronSecureDocIntegration();

        // Step 1: Fetch image metadata or download from Immich
        string imageData = await immich.GetImageFromImmich(immichImageId, immichBaseUrl, immichApiKey);

        // Step 2: Optionally download the image locally using imageData URL (not shown here)
        // Assume imagePath is the downloaded image file path

        // Step 3: Upload the image to IronSecureDoc
        await ironSecureDoc.UploadImageTo IronSecureDoc(imagePath);
    }
}

Verwenden Sie die API von IronSecureDoc, um Fotos anzuhängen und digitale Signaturen anzuwenden. Fügen Sie den notwendigen API-Aufruf in die IronSecureDocIntegration Klasse ein, um das Dokument zu vervollständigen. Unten ist das Beispiel-PDF, das vom IronSecureDoc nach dem Hinzufügen der Signatur generiert wurde.

Abschluss

Während sowohl Immich als auch IronSecureDoc einen hervorragenden Job machen, auf spezifische Bedürfnisse zu reagieren, bedienen sie jeweils unterschiedliche Anwendungsfälle am besten. Immich leistet hervorragende Arbeit bei der selbstgehosteten, funktionsreichen Foto- und Videomanagement, wie Gesichtserkennung, Objekterkennung und straffe Organisation von Multimedia-Dateien. Es ist ideal für persönliches oder kleinmaßstäbliches Medienstandortmanagement, bei dem man eine Lösung möchte, die genau auf die eigenen Bedürfnisse zugeschnitten ist.

IronSecureDoc ist eine organisationsweite, sichere Dokumenten- und Signaturlösung, die die fantastischen Vorteile der erweiterten Verschlüsselung mit der Einfachheit der Workflow-Integration verbindet, um Sicherheit, Skalierbarkeit und professionelles Dokumentenmanagement zu ermöglichen.

Zuverlässig und konform: Da es umfassende Prüfungsfunktionen mit starker Sicherheit bietet, ist es zuverlässig und konform. Dank der IronSecureDoc REST-API können Entwickler von Web-, Mobil- und Unternehmenssystemen nun problemlos sicheren Druck sowie effizientes PDF-Format und -Handling in ihre Anwendungen integrieren. Um mehr über die Lizenzierung von IronSecureDoc zu erfahren, besuchen Sie die Lizenzierungsseite. Um mehr über die Angebote von Iron Software zu erfahren, besuchen Sie die Iron Suite Seite.