· Nacho Coll · Guides  · 8 Min. Lesezeit

IPFS CID erklärt: Was es ist und wie Content-Addressing funktioniert

Klare technische Erklärung von IPFS Content Identifiers (CIDs). Wie Content-Addressing funktioniert, CID-Versionen und das Erstellen Ihres ersten CIDs.

Klare technische Erklärung von IPFS Content Identifiers (CIDs). Wie Content-Addressing funktioniert, CID-Versionen und das Erstellen Ihres ersten CIDs.

Wer schon einmal mit IPFS (InterPlanetary File System) gearbeitet hat, ist mit hoher Wahrscheinlichkeit auf Zeichenketten wie QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG oder bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi gestoßen. Das ist kein zufälliges Kauderwelsch — es sind Content Identifiers (CIDs), das Rückgrat des Content-Addressing-Systems von IPFS.

CIDs zu verstehen ist entscheidend für alle, die auf IPFS aufbauen — ob Sie Dateien hochladen, dezentrale Anwendungen entwickeln oder Content-Delivery-Systeme implementieren. Dieser Leitfaden zerlegt alles, was Sie über IPFS-CIDs wissen müssen: wie Content-Addressing funktioniert und wie Sie es in Ihren Projekten einsetzen.

IPFS Ninja

Was ist ein IPFS-CID?

Ein Content Identifier (CID) ist ein eindeutiger Fingerabdruck, der einen Inhalt in IPFS repräsentiert. Im Gegensatz zu klassischen Web-URLs, die auf einen Ort verweisen (etwa https://example.com/file.pdf), verweisen CIDs auf den Inhalt selbst — unabhängig davon, wo er gespeichert ist.

So lässt es sich vorstellen:

  • Standortbasierte Adressierung: „Geh zur Hauptstraße 123 und frag nach dem roten Buch”
  • Inhaltsbasierte Adressierung: „Finde das Buch mit ISBN 978-0-123456-78-9” (egal, in welcher Bibliothek es steht)

CIDs funktionieren analog — sie identifizieren Inhalte über deren kryptografischen Hash. Das macht den Inhalt unveränderlich und verifizierbar. Ändert sich auch nur ein einzelnes Byte in der Datei, ändert sich der CID komplett.

Warum Content-Addressing wichtig ist

Die klassische Webarchitektur stützt sich auf standortbasierte Adressierung. Wenn Sie https://example.com/image.jpg aufrufen, vertrauen Sie darauf, dass:

  1. Der Domain-Eigentümer den Inhalt nicht geändert hat
  2. Der Server online und erreichbar ist
  3. Der Inhalt nicht manipuliert wurde

Mit Content-Addressing über CIDs:

  1. Unveränderlichkeit: Der CID garantiert, dass sich der Inhalt nicht geändert hat
  2. Dezentralisierung: Inhalte können von jedem IPFS-Knoten abgerufen werden, der sie hat
  3. Verifikation: Sie können kryptografisch prüfen, ob Sie den richtigen Inhalt erhalten haben
  4. Effizienz: Identische Inhalte werden automatisch dedupliziert

Aufbau eines CIDs

Sezieren wir einen typischen CID, um seine Bestandteile zu verstehen:

bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
└─┬─┘└─────────────────┬─────────────────────────────────┘
  │                   │
  │                   └─ Content Hash (Base32 codiert)
  └─ Multibase-Präfix (kennzeichnet die Codierung)

Ein CID enthält mehrere Informationen:

1. Multibase-Präfix

Das erste Zeichen zeigt an, wie der CID codiert ist:

  • Q = Base58-Codierung (CIDv0)
  • b = Base32-Codierung (CIDv1)
  • f = Base16/Hexadezimal (CIDv1)
  • z = Base58 (CIDv1)

2. CID-Version

  • CIDv0: Beginnt immer mit Qm, nutzt SHA-256, beschränkt auf den DAG-PB-Codec
  • CIDv1: Flexibler, unterstützt mehrere Hash-Funktionen und Codecs

3. Multicodec

Spezifiziert, wie der Inhalt strukturiert ist (DAG-PB, DAG-CBOR, Raw Bytes usw.)

4. Multihash

Der eigentliche kryptografische Hash des Inhalts, inklusive:

  • Kennung der Hash-Funktion (meist SHA-256)
  • Hash-Länge
  • Der Hash-Digest

CIDv0 vs. CIDv1: Die Unterschiede verstehen

IPFS hat zwei wichtige CID-Versionen durchlaufen, jede mit eigenem Charakter:

CIDv0: Das Originalformat

CIDv0-CIDs beginnen immer mit Qm und sehen so aus:

QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG

Eigenschaften:

  • Ausschließlich Base58-Codierung
  • Nur SHA-256-Hash-Funktion
  • Nur DAG-PB (Protobuf)-Codec
  • 46 Zeichen lang
  • Abwärtskompatibel mit allen IPFS-Implementierungen

Wann CIDv0 nutzen:

  • Maximale Kompatibilität mit älteren IPFS-Knoten
  • Bei Bestandssystemen, die Qm-Präfixe erwarten
  • Dateispeicherung (häufigster Anwendungsfall)

CIDv1: Der moderne Standard

CIDv1-CIDs sind flexibler und können so aussehen:

bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi  # Base32
zb2rhj7crUKTQYRGCRATFaQ6YFLTde2YzdqbbhAASkL9uRDXn      # Base58
f01551220d1e2c35...                                      # Base16

Eigenschaften:

  • Mehrere Codierungsformate (Base32, Base58, Base16)
  • Unterstützung für verschiedene Hash-Funktionen (SHA-256, SHA-512, BLAKE2 usw.)
  • Mehrere Codecs (Raw, DAG-CBOR, DAG-JSON usw.)
  • Selbstbeschreibendes Format
  • Bei Base32 case-insensitive

Wann CIDv1 nutzen:

  • Beim Aufbau neuer Anwendungen
  • Bei Bedarf an case-insensitiven Identifikatoren
  • Bei strukturierten Daten (JSON, CBOR)
  • Bei Verwendung alternativer Hash-Funktionen

Versionen umwandeln

Sie können CIDs zwischen Versionen umwandeln und dabei dieselbe Inhaltsreferenz behalten:

// CIDv0
const cidv0 = "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG";

// Convert to CIDv1 Base32
const cidv1 = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi";

// Both reference the same content!

So funktioniert Content-Addressing

Content-Addressing in IPFS folgt einem deterministischen Prozess, der sicherstellt, dass derselbe Inhalt immer denselben CID erzeugt:

1. Inhaltsvorbereitung

Wenn Sie Inhalte zu IPFS hinzufügen, werden sie zunächst zerlegt:

  • Kleine Dateien: Als einzelne Blöcke gespeichert
  • Große Dateien: In Chunks aufgeteilt und in einem Merkle-DAG (Directed Acyclic Graph) organisiert
  • Verzeichnisse: Als DAG-Strukturen mit Verknüpfungen zu Dateien dargestellt

2. Hashing-Prozess

Jedes Stück Inhalt durchläuft:

  1. Serialisierung: Inhalt wird gemäß seinem Codec formatiert
  2. Hashing: Kryptografische Hash-Funktion verarbeitet die serialisierten Daten
  3. Multihash-Erstellung: Hash wird mit Algorithmus- und Längeninformation umhüllt
  4. CID-Zusammensetzung: Version, Codec und Multihash werden kombiniert

3. Merkle-DAG-Struktur

IPFS organisiert Inhalte in einem Merkle-DAG, in dem:

  • Jeder Knoten einen CID hat
  • Übergeordnete Knoten auf Kind-Knoten via CID verweisen
  • Änderungen an Knoten den Baum nach oben propagieren
  • Ganze Strukturen kryptografisch verifizierbar sind
Root CID: bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
├── file1.txt (QmHash1...)
├── file2.jpg (QmHash2...)
└── subdirectory/
    ├── file3.pdf (QmHash3...)
    └── file4.mp4 (QmHash4...)

Praktische Beispiele: Arbeit mit CIDs

Sehen wir uns an, wie man CIDs in der Praxis mit der API von IPFS Ninja nutzt:

Inhalte hochladen und einen CID erhalten

// Upload a file and get its CID
const uploadFile = async (content, filename) => {
  const response = await fetch('https://api.ipfs.ninja/upload/new', {
    method: 'POST',
    headers: {
      'X-Api-Key': 'bws_1234567890abcdef1234567890abcdef12345678',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      content: btoa(content), // Base64 encode binary content
      description: `Upload of ${filename}`
    })
  });
  
  const result = await response.json();
  console.log('CID:', result.cid);
  console.log('IPFS URL:', result.uris.ipfs);
  console.log('HTTP URL:', result.uris.url);
  
  return result.cid;
};

// Example usage
uploadFile('Hello, IPFS!', 'greeting.txt');
// Returns: bafkreifjxz6zwqh27k5xnr5qfbx4w6n5vuwwwdcngguwjewzj2e3xxfgvi

Bestehende Inhalte per CID pinnen

Wenn Sie bereits einen CID haben, können Sie diesen pinnen, damit der Inhalt verfügbar bleibt:

const pinByCID = async (cid) => {
  const response = await fetch('https://api.ipfs.ninja/pin', {
    method: 'POST',
    headers: {
      'X-Api-Key': 'bws_1234567890abcdef1234567890abcdef12345678',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      cid: cid,
      description: 'Pinned via API'
    })
  });
  
  const result = await response.json();
  console.log('Pinned CID:', result.cid);
  
  return result;
};

// Pin the "Hello World" of IPFS
pinByCID('QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u');

Inhalte via CID abrufen

Sobald Sie einen CID haben, können Sie den Inhalt über verschiedene Wege abrufen:

// Direct IPFS gateway access
const ipfsUrl = `https://ipfs.ninja/ipfs/${cid}`;

// Custom gateway (if configured)
const customGatewayUrl = `https://my-app.gw.ipfs.ninja/ipfs/${cid}`;

// Fetch content programmatically
const fetchContent = async (cid) => {
  const response = await fetch(`https://ipfs.ninja/ipfs/${cid}`);
  const content = await response.text();
  return content;
};

CID-Best-Practices für Entwickler

1. CIDs immer validieren

Bevor Sie einen CID in Ihrer Anwendung verwenden, validieren Sie das Format:

const isValidCID = (cid) => {
  // Basic validation patterns
  const cidv0Pattern = /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/;
  const cidv1Pattern = /^[bf][a-z2-7]{58}$/;
  
  return cidv0Pattern.test(cid) || cidv1Pattern.test(cid);
};

2. Beide CID-Versionen unterstützen

Ihre Anwendung sollte sowohl mit CIDv0 als auch mit CIDv1 arbeiten:

const normalizeCID = (cid) => {
  if (cid.startsWith('Qm')) {
    // CIDv0 - can convert to CIDv1 if needed
    return cid;
  } else if (cid.startsWith('b') || cid.startsWith('f') || cid.startsWith('z')) {
    // CIDv1
    return cid;
  } else {
    throw new Error('Invalid CID format');
  }
};

3. CID-Zuordnungen cachen

Wenn Sie häufig CIDs erzeugen, empfiehlt sich Caching:

const cidCache = new Map();

const getCachedCID = (content) => {
  const contentHash = btoa(content);
  
  if (cidCache.has(contentHash)) {
    return cidCache.get(contentHash);
  }
  
  // Upload and cache result
  return uploadFile(content).then(cid => {
    cidCache.set(contentHash, cid);
    return cid;
  });
};

4. Aussagekräftige Beschreibungen verwenden

Wenn Sie Inhalte hochladen, hinterlegen Sie aussagekräftige Metadaten:

const uploadWithMetadata = async (content, metadata) => {
  return fetch('https://api.ipfs.ninja/upload/new', {
    method: 'POST',
    headers: {
      'X-Api-Key': 'bws_1234567890abcdef1234567890abcdef12345678',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      content: btoa(content),
      description: metadata.name || 'Uploaded file',
      metadata: {
        filename: metadata.filename,
        contentType: metadata.contentType,
        uploadedAt: new Date().toISOString(),
        version: metadata.version || '1.0'
      }
    })
  });
};

Gängige CID-Anwendungsfälle

1. Deployment statischer Websites

Stellen Sie komplette Websites auf IPFS bereit und referenzieren Sie sie per CID:

// Upload website directory structure
const deployWebsite = async (files) => {
  const uploads = await Promise.all(
    files.map(file => uploadFile(file.content, file.path))
  );
  
  // Root CID references entire site
  const rootCID = uploads.find(u => u.path === 'index.html').cid;
  console.log(`Website deployed: https://ipfs.ninja/ipfs/${rootCID}`);
  
  return rootCID;
};

Mehr zum Website-Deployment finden Sie in unserem Leitfaden zum Hochladen von Dateien auf IPFS.

2. NFT-Metadaten speichern

Speichern Sie NFT-Metadaten unveränderlich via CID:

const nftMetadata = {
  name: "My Awesome NFT",
  description: "A unique digital collectible",
  image: "ipfs://bafkreibc5sgo2plmjkq2tzmhrn54bk3crhnqekiy7u66fqvqm37pu2e5gw",
  attributes: [
    { trait_type: "Color", value: "Blue" },
    { trait_type: "Rarity", value: "Epic" }
  ]
};

const metadataCID = await uploadFile(
  JSON.stringify(nftMetadata, null, 2), 
  'metadata.json'
);

// Use in smart contract
console.log(`Token URI: ipfs://${metadataCID}`);

3. Content-Distribution

Nutzen Sie CIDs für verteilte Content-Auslieferung:

// Upload once, access everywhere
const distributeContent = async (content) => {
  const cid = await uploadFile(content, 'content.txt');
  
  // Content available via multiple gateways
  const gateways = [
    `https://ipfs.ninja/ipfs/${cid}`,
    `https://ipfs.io/ipfs/${cid}`,
    `https://cloudflare-ipfs.com/ipfs/${cid}`
  ];
  
  return { cid, gateways };
};

IPFS-Pinning mit CIDs verstehen

CIDs sind standardmäßig vorübergehend — sie müssen „gepinnt” werden, um verfügbar zu bleiben. Mehr zu diesem entscheidenden Konzept in unserem umfassenden Leitfaden zu Was ist IPFS-Pinning.

Bei der Wahl eines IPFS-Pinning-Dienstes lohnt sich auch unser Vergleich IPFS Ninja vs Pinata sowie unsere Übersicht der besten IPFS-Pinning-Dienste, die heute verfügbar sind.

Ihren ersten CID in 30 Sekunden erstellen

Bereit, Ihren ersten CID zu erzeugen? Hier ein Schnellbeispiel mit der API von IPFS Ninja:

# Using curl (replace with your actual API key)
curl -X POST https://api.ipfs.ninja/upload/new \
  -H "X-Api-Key: bws_YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "SGVsbG8sIElQRlMgV29ybGQh",
    "description": "My first IPFS upload"
  }'
// Using JavaScript
const createFirstCID = async () => {
  const response = await fetch('https://api.ipfs.ninja/upload/new', {
    method: 'POST',
    headers: {
      'X-Api-Key': 'bws_YOUR_API_KEY_HERE',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      content: btoa('Hello, IPFS World!'), // Base64: "SGVsbG8sIElQRlMgV29ybGQh"
      description: 'My first IPFS upload'
    })
  });
  
  const result = await response.json();
  console.log('🎉 Your first CID:', result.cid);
  console.log('🌐 Access it at:', result.uris.url);
  
  return result;
};

createFirstCID();

Das liefert in etwa Folgendes:

{
  "cid": "bafkreif2pall7dybz7vecqka3zo24irdwabf7rbiiweuhau7a2hjlqvfjw",
  "sizeMB": 0.000017,
  "uris": {
    "ipfs": "ipfs://bafkreif2pall7dybz7vecqka3zo24irdwabf7rbiiweuhau7a2hjlqvfjw",
    "url": "https://ipfs.ninja/ipfs/bafkreif2pall7dybz7vecqka3zo24irdwabf7rbiiweuhau7a2hjlqvfjw"
  }
}

Für ausführlichere API-Beispiele sehen Sie sich unser IPFS-Upload-API-Tutorial an.

Fazit

CIDs sind das Fundament des Content-Addressing-Systems von IPFS und bieten unveränderliche, verifizierbare und dezentrale Inhaltsidentifikation. Zu verstehen, wie sie funktionieren — von den technischen Details zu CIDv0 vs. CIDv1 bis zu praktischen Implementierungsmustern — ist essenziell für robuste dezentrale Anwendungen.

Wichtige Erkenntnisse:

  • CIDs identifizieren Inhalte eindeutig, nicht Standorte
  • CIDv0 bietet maximale Kompatibilität, CIDv1 mehr Flexibilität
  • Content-Addressing ermöglicht Verifikation und Deduplikation
  • Sauberer CID-Umgang ist entscheidend für produktive Anwendungen

Ob Sie NFT-Metadaten speichern, dezentrale Websites deployen oder Content-Distribution-Systeme bauen — CIDs liefern das verlässliche Fundament, das Sie für wirklich dezentrale Anwendungen brauchen.

Bereit zum Pinnen? Kostenlosen Account erstellen — 50 Dateien, 1 GB Speicher, 2 GB Bandbreite/Monat. Keine Kreditkarte erforderlich.

Share:
Zurück zum Blog

Verwandte Artikel

Alle Artikel anzeigen »