· Nacho Coll · Guides  · 8 min lesing

IPFS CID forklart: hva det er og hvordan innholdsadressering fungerer

Klar teknisk forklaring av IPFS Content Identifiers (CIDs). Hvordan innholdsadressering fungerer, CID-versjoner og hvordan du oppretter din første CID.

Klar teknisk forklaring av IPFS Content Identifiers (CIDs). Hvordan innholdsadressering fungerer, CID-versjoner og hvordan du oppretter din første CID.

Hvis du noen gang har jobbet med IPFS (InterPlanetary File System), har du sannsynligvis sett strenger som QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG eller bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi. Dette er ikke tilfeldig vrøvl — det er Content Identifiers (CIDs), ryggraden i IPFS’ innholdsadresseringssystem.

Å forstå CIDs er avgjørende for alle som bygger på IPFS, enten du laster opp filer, bygger desentraliserte applikasjoner eller implementerer innholdsdistribusjonssystemer. Denne guiden vil dekke alt du trenger å vite om IPFS CIDs, hvordan innholdsadressering fungerer, og hvordan du kommer i gang med å bruke dem i prosjektene dine.

IPFS Ninja

Hva er en IPFS CID?

En Content Identifier (CID) er et unikt fingeravtrykk som representerer et innholdsstykke på IPFS. I motsetning til tradisjonelle web-URL-er som peker til en plassering (som https://example.com/file.pdf), peker CIDs til selve innholdet, uansett hvor det er lagret.

Tenk på det slik:

  • Plasseringsbasert adressering: “Gå til Hovedgaten 123 og spør om den røde boken”
  • Innholdsbasert adressering: “Finn boken med ISBN 978-0-123456-78-9” (hvilket bibliotek som har den, spiller ingen rolle)

CIDs fungerer på lignende måte — de identifiserer innhold basert på dets kryptografiske hash, og gjør innholdet uforanderlig og verifiserbart. Hvis en eneste byte endres i filen, endres CID-en helt.

Hvorfor innholdsadressering er viktig

Tradisjonell webarkitektur er avhengig av plasseringsbasert adressering. Når du besøker https://example.com/image.jpg, stoler du på at:

  1. Domeneieren ikke har endret innholdet
  2. Serveren er online og tilgjengelig
  3. Innholdet ikke er blitt manipulert

Med innholdsadressering ved bruk av CIDs:

  1. Uforanderlighet: CID-en garanterer at innholdet ikke er endret
  2. Desentralisering: Innhold kan hentes fra hvilken som helst IPFS-node som har det
  3. Verifisering: Du kan kryptografisk verifisere at du mottok riktig innhold
  4. Effektivitet: Identisk innhold dedupliseres automatisk

Anatomien til en CID

La oss bryte ned en typisk CID for å forstå komponentene:

bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
└─┬─┘└─────────────────┬─────────────────────────────────┘
  │                   │
  │                   └─ Innholdshash (Base32-kodet)
  └─ Multibase-prefiks (angir koding)

En CID inneholder flere informasjonsbiter:

1. Multibase-prefiks

Det første tegnet angir hvordan CID-en er kodet:

  • Q = Base58-koding (CIDv0)
  • b = Base32-koding (CIDv1)
  • f = Base16/heksadesimal (CIDv1)
  • z = Base58 (CIDv1)

2. CID-versjon

  • CIDv0: Starter alltid med Qm, bruker SHA-256, begrenset til DAG-PB codec
  • CIDv1: Mer fleksibel, støtter flere hash-funksjoner og codecs

3. Multicodec

Spesifiserer hvordan innhold er strukturert (DAG-PB, DAG-CBOR, rå bytes, osv.)

4. Multihash

Den faktiske kryptografiske hashen av innholdet, inkludert:

  • Hashfunksjons-identifikator (vanligvis SHA-256)
  • Hash-lengde
  • Hash-digesten

CIDv0 vs CIDv1: Forstå forskjellene

IPFS har utviklet seg gjennom to store CID-versjoner, hver med distinkte egenskaper:

CIDv0: Det originale formatet

CIDv0 CIDs starter alltid med Qm og ser slik ut:

QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG

Egenskaper:

  • Kun Base58-koding
  • Kun SHA-256 hashfunksjon
  • Kun DAG-PB (Protobuf) codec
  • 46 tegn lang
  • Bakoverkompatibel med alle IPFS-implementasjoner

Når man skal bruke CIDv0:

  • Maksimal kompatibilitet med eldre IPFS-noder
  • Arbeid med eksisterende systemer som forventer Qm-prefiks
  • Fillagring (vanligste bruksområde)

CIDv1: Den moderne standarden

CIDv1 CIDs er mer fleksible og kan se slik ut:

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

Egenskaper:

  • Flere kodingsformater (Base32, Base58, Base16)
  • Støtte for ulike hashfunksjoner (SHA-256, SHA-512, BLAKE2, osv.)
  • Flere codecs (Raw, DAG-CBOR, DAG-JSON, osv.)
  • Selvbeskrivende format
  • Ikke skiftforskjellig ved Base32-bruk

Når man skal bruke CIDv1:

  • Bygge nye applikasjoner
  • Trenger skiftforskjellige identifikatorer
  • Arbeid med strukturert data (JSON, CBOR)
  • Bruk alternative hashfunksjoner

Konvertering mellom versjoner

Du kan konvertere CIDs mellom versjoner samtidig som du opprettholder samme innholdsreferanse:

// CIDv0
const cidv0 = "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG";

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

// Both reference the same content!

Hvordan innholdsadressering fungerer

Innholdsadressering i IPFS følger en deterministisk prosess som sikrer at det samme innholdet alltid produserer samme CID:

1. Innholdsforberedelse

Når du legger til innhold i IPFS, blir det først brutt ned:

  • Små filer: Lagres som enkle blokker
  • Store filer: Deles opp i biter og organiseres i en Merkle DAG (Directed Acyclic Graph)
  • Kataloger: Representeres som DAG-strukturer som lenker til filer

2. Hashing-prosessen

Hvert innholdsstykke gjennomgår:

  1. Serialisering: Innhold formateres i henhold til sin codec
  2. Hashing: Kryptografisk hashfunksjon behandler den serialiserte dataen
  3. Multihash-opprettelse: Hash pakkes med algoritme- og lengdeinformasjon
  4. CID-sammensetning: Versjon, codec og multihash kombineres

3. Merkle DAG-struktur

IPFS organiserer innhold i en Merkle DAG hvor:

  • Hver node har en CID
  • Foreldrenoder refererer til barnenoder via CID
  • Endringer i en node sprer seg oppover treet
  • Hele strukturer kan kryptografisk verifiseres
Root CID: bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
├── file1.txt (QmHash1...)
├── file2.jpg (QmHash2...)
└── subdirectory/
    ├── file3.pdf (QmHash3...)
    └── file4.mp4 (QmHash4...)

Praktiske eksempler: Arbeid med CIDs

La oss utforske hvordan man jobber med CIDs i praksis ved hjelp av IPFS Ninja API:

Last opp innhold og 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

Pin eksisterende innhold med CID

Hvis du allerede har en CID, kan du pinne den for å sikre tilgjengelighet:

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

Tilgang til innhold via CID

Når du har en CID, kan du få tilgang til innholdet via ulike metoder:

// 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-beste praksis for utviklere

1. Valider alltid CIDs

Før du bruker en CID i applikasjonen din, valider formatet:

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. Håndter begge CID-versjoner

Applikasjonen din bør fungere med både CIDv0 og 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. Cache CID-mappinger

Hvis du genererer CIDs ofte, vurder 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. Bruk meningsfulle beskrivelser

Når du laster opp innhold, inkluder beskrivende 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'
      }
    })
  });
};

Vanlige CID-bruksområder

1. Statisk nettstedutrulling

Rull ut hele nettsteder til IPFS og referer 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;
};

For å lære mer om nettstedutrulling, sjekk ut guiden vår om hvordan laste opp filer til IPFS.

2. NFT-metadatalagring

Lagre NFT-metadata uforanderlig ved bruk av 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. Innholdsdistribusjon

Bruk CIDs for distribuert innholdslevering:

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

Forstå IPFS-pinning med CIDs

CIDs er midlertidige som standard — de må “pinnes” for å forbli tilgjengelige. Lær mer om dette avgjørende konseptet i vår omfattende guide om hva IPFS-pinning er.

Når du velger en IPFS-pinningstjeneste, vurder å lese vår IPFS Ninja vs Pinata sammenligning eller utforsk vår oversikt over de beste IPFS-pinningstjenestene som er tilgjengelige i dag.

Opprett din første CID på 30 sekunder

Klar til å generere din første CID? Her er et raskt eksempel ved bruk av 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();

Dette vil returnere noe som:

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

For mer detaljerte API-eksempler, se vår IPFS opplastings-API-tutorial.

Konklusjon

CIDs er fundamentet for IPFS’ innholdsadresseringssystem, og gir uforanderlig, verifiserbar og desentralisert innholdsidentifikasjon. Å forstå hvordan de fungerer — fra de tekniske detaljene i CIDv0 vs CIDv1 til praktiske implementeringsmønstre — er essensielt for å bygge robuste desentraliserte applikasjoner.

Viktige punkter:

  • CIDs identifiserer innhold unikt, ikke plasseringer
  • CIDv0 gir maksimal kompatibilitet, CIDv1 tilbyr fleksibilitet
  • Innholdsadressering muliggjør verifikasjon og deduplisering
  • Korrekt CID-håndtering er avgjørende for produksjonsapplikasjoner

Enten du lagrer NFT-metadata, ruller ut desentraliserte nettsteder eller bygger innholdsdistribusjonssystemer, gir CIDs det pålitelige fundamentet du trenger for virkelig desentraliserte applikasjoner.

Klar til å begynne å pinne? Opprett en gratis konto — 50 filer, 1 GB lagring, 2 GB båndbredde/måned. Ingen kredittkort kreves.

Share:
Tilbake til Bloggen

Relaterte artikler

Se alle artikler »