· Nacho Coll · Guides  · 8 min läsning

IPFS CID förklarat: vad det är och hur innehållsadressering fungerar

Tydlig teknisk förklaring av IPFS Content Identifiers (CIDs). Hur innehållsadressering fungerar, CID-versioner och hur du skapar din första CID.

Tydlig teknisk förklaring av IPFS Content Identifiers (CIDs). Hur innehållsadressering fungerar, CID-versioner och hur du skapar din första CID.

Om du någonsin har arbetat med IPFS (InterPlanetary File System) har du förmodligen stött på strängar som QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG eller bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi. Dessa är inte slumpmässigt nonsens — de är Content Identifiers (CIDs), ryggraden i IPFS innehållsadresseringssystem.

Att förstå CIDs är avgörande för alla som bygger på IPFS, oavsett om du laddar upp filer, bygger decentraliserade applikationer eller implementerar innehållsdistributionssystem. Den här guiden bryter ner allt du behöver veta om IPFS CIDs, hur innehållsadressering fungerar och hur du kommer igång med att använda dem i dina projekt.

IPFS Ninja

Vad är en IPFS CID?

En Content Identifier (CID) är ett unikt fingeravtryck som representerar ett innehåll på IPFS. Till skillnad från traditionella webb-URL:er som pekar på en plats (som https://example.com/file.pdf), pekar CIDs på själva innehållet, oavsett var det lagras.

Tänk på det så här:

  • Platsbaserad adressering: “Gå till Huvudgatan 123 och be om den röda boken”
  • Innehållsbaserad adressering: “Hitta boken med ISBN 978-0-123456-78-9” (vilket bibliotek som har den spelar ingen roll)

CIDs fungerar på liknande sätt — de identifierar innehåll baserat på dess kryptografiska hash, vilket gör innehållet oföränderligt och verifierbart. Om en enda byte ändras i filen ändras CID:n helt.

Varför innehållsadressering är viktig

Traditionell webbarkitektur bygger på platsbaserad adressering. När du besöker https://example.com/image.jpg litar du på att:

  1. Domänägaren inte har ändrat innehållet
  2. Servern är online och tillgänglig
  3. Innehållet inte har manipulerats

Med innehållsadressering med CIDs:

  1. Oföränderlighet: CID:n garanterar att innehållet inte har ändrats
  2. Decentralisering: Innehåll kan hämtas från vilken IPFS-nod som helst som har det
  3. Verifiering: Du kan kryptografiskt verifiera att du fick rätt innehåll
  4. Effektivitet: Identiskt innehåll dedupliceras automatiskt

Anatomi av en CID

Låt oss bryta ner en typisk CID för att förstå dess komponenter:

bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
└─┬─┘└─────────────────┬─────────────────────────────────┘
  │                   │
  │                   └─ Innehållshash (Base32-kodad)
  └─ Multibase-prefix (anger kodning)

En CID innehåller flera informationsdelar:

1. Multibase-prefix

Det första tecknet anger hur CID:n är kodad:

  • Q = Base58-kodning (CIDv0)
  • b = Base32-kodning (CIDv1)
  • f = Base16/hexadecimalt (CIDv1)
  • z = Base58 (CIDv1)

2. CID-version

  • CIDv0: Börjar alltid med Qm, använder SHA-256, begränsad till DAG-PB-codec
  • CIDv1: Mer flexibel, stöder flera hashfunktioner och codecs

3. Multicodec

Anger hur innehåll är strukturerat (DAG-PB, DAG-CBOR, råa bytes, etc.)

4. Multihash

Innehållets faktiska kryptografiska hash, inklusive:

  • Hashfunktionsidentifierare (vanligtvis SHA-256)
  • Hashlängd
  • Hash-digesten

CIDv0 vs CIDv1: Förstå skillnaderna

IPFS har utvecklats genom två stora CID-versioner, var och en med distinkta egenskaper:

CIDv0: Det ursprungliga formatet

CIDv0 CIDs börjar alltid med Qm och ser ut så här:

QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG

Egenskaper:

  • Endast Base58-kodning
  • Endast SHA-256-hashfunktion
  • Endast DAG-PB (Protobuf) codec
  • 46 tecken lång
  • Bakåtkompatibla med alla IPFS-implementationer

När man ska använda CIDv0:

  • Maximal kompatibilitet med äldre IPFS-noder
  • Arbeta med befintliga system som förväntar sig Qm-prefix
  • Fillagring (vanligaste användningsfallet)

CIDv1: Den moderna standarden

CIDv1 CIDs är mer flexibla och kan se ut så här:

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

Egenskaper:

  • Flera kodningsformat (Base32, Base58, Base16)
  • Stöd för olika hashfunktioner (SHA-256, SHA-512, BLAKE2, etc.)
  • Flera codecs (Raw, DAG-CBOR, DAG-JSON, etc.)
  • Självbeskrivande format
  • Inte skiftlägeskänsligt vid Base32-användning

När man ska använda CIDv1:

  • Bygga nya applikationer
  • Behöver skiftlägeskänsliga identifierare
  • Arbeta med strukturerad data (JSON, CBOR)
  • Använda alternativa hashfunktioner

Konvertera mellan versioner

Du kan konvertera CIDs mellan versioner samtidigt som du behåller samma innehållsreferens:

// CIDv0
const cidv0 = "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG";

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

// Both reference the same content!

Hur innehållsadressering fungerar

Innehållsadressering i IPFS följer en deterministisk process som säkerställer att samma innehåll alltid ger samma CID:

1. Innehållsförberedelse

När du lägger till innehåll till IPFS bryts det först ner:

  • Små filer: Lagras som enstaka block
  • Stora filer: Delas upp i bitar och organiseras i en Merkle DAG (riktad acyklisk graf)
  • Kataloger: Representeras som DAG-strukturer som länkar till filer

2. Hashprocessen

Varje del av innehållet går igenom:

  1. Serialisering: Innehåll formateras enligt sin codec
  2. Hashning: Kryptografisk hashfunktion bearbetar den serialiserade datan
  3. Multihash-skapande: Hash omsluts med algoritm- och längdinformation
  4. CID-montering: Version, codec och multihash kombineras

3. Merkle DAG-struktur

IPFS organiserar innehåll i en Merkle DAG där:

  • Varje nod har en CID
  • Föräldranoder refererar till barnnoder via CID
  • Ändringar i någon nod sprider sig uppåt i trädet
  • Hela strukturer kan kryptografiskt verifieras
Root CID: bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
├── file1.txt (QmHash1...)
├── file2.jpg (QmHash2...)
└── subdirectory/
    ├── file3.pdf (QmHash3...)
    └── file4.mp4 (QmHash4...)

Praktiska exempel: Arbeta med CIDs

Låt oss utforska hur man arbetar med CIDs i praktiken med IPFS Ninja API:

Ladda upp innehåll och få en CID

// 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

Pinna befintligt innehåll med CID

Om du redan har en CID kan du pinna den för att säkerställa tillgänglighet:

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');

Åtkomst till innehåll via CID

När du har en CID kan du komma åt innehållet på flera sätt:

// 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-bästa praxis för utvecklare

1. Validera alltid CIDs

Innan du använder en CID i din applikation, validera dess 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. Hantera båda CID-versionerna

Din applikation bör fungera med både CIDv0 och CIDv1:

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. Cachea CID-mappningar

Om du genererar CIDs ofta, överväg 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. Använd meningsfulla beskrivningar

När du laddar upp innehåll, inkludera beskrivande metadata:

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'
      }
    })
  });
};

Vanliga användningsfall för CID

1. Statisk webbplatsdistribution

Distribuera hela webbplatser till IPFS och referera dem med 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;
};

För att lära dig mer om webbplatsdistribution, kolla in vår guide om hur man laddar upp filer till IPFS.

2. NFT-metadatalagring

Lagra NFT-metadata oföränderligt med CIDs:

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. Innehållsdistribution

Använd CIDs för distribuerad innehållsleverans:

// 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 };
};

Förstå IPFS-pinning med CIDs

CIDs är temporära som standard — de måste “pinnas” för att förbli tillgängliga. Lär dig mer om detta avgörande koncept i vår omfattande guide om vad IPFS-pinning är.

När du väljer en IPFS-pinningtjänst, överväg att läsa vår IPFS Ninja vs Pinata jämförelse eller utforska vår sammanställning av de bästa IPFS-pinningtjänsterna som finns tillgängliga idag.

Skapa din första CID på 30 sekunder

Redo att generera din första CID? Här är ett snabbt exempel med IPFS Ninja API:

# 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();

Detta kommer att returnera något som:

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

För mer detaljerade API-exempel, se vår IPFS uppladdnings-API-handledning.

Slutsats

CIDs är grunden för IPFS innehållsadresseringssystem och ger oföränderlig, verifierbar och decentraliserad innehållsidentifiering. Att förstå hur de fungerar — från de tekniska detaljerna i CIDv0 vs CIDv1 till praktiska implementeringsmönster — är avgörande för att bygga robusta decentraliserade applikationer.

Viktiga punkter:

  • CIDs identifierar innehåll unikt, inte platser
  • CIDv0 ger maximal kompatibilitet, CIDv1 erbjuder flexibilitet
  • Innehållsadressering möjliggör verifiering och deduplicering
  • Korrekt CID-hantering är avgörande för produktionsapplikationer

Oavsett om du lagrar NFT-metadata, distribuerar decentraliserade webbplatser eller bygger innehållsdistributionssystem, ger CIDs den pålitliga grunden du behöver för verkligt decentraliserade applikationer.

Redo att börja pinna? Skapa ett gratis konto — 50 filer, 1 GB lagring, 2 GB bandbredd/månad. Inget kreditkort krävs.

Share:
Tillbaka till Bloggen

Relaterade artiklar

Visa alla artiklar »