IPFS CIDs 2026: Sådan virker content addressing

Hvis du nogensinde har arbejdet med IPFS (InterPlanetary File System), er du sandsynligvis stødt på strenge som QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG eller bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi. Disse er ikke tilfældigt nonsens — de er Content Identifiers (CIDs), rygraden i IPFS’ content-adresseringssystem.

At forstå CIDs er afgørende for enhver, der bygger på IPFS, uanset om du uploader filer, bygger decentraliserede applikationer eller implementerer content-distributionssystemer. Denne guide vil bryde alt ned, hvad du behøver at vide om IPFS CIDs, hvordan content-adressering virker, og hvordan du kommer i gang med at bruge dem i dine projekter.

Generer en CID på 5 linjer (Python)#

import hashlib, base58

def cidv0(content: bytes) -> str:
    sha256 = hashlib.sha256(content).digest()
    return base58.b58encode(b"\x12\x20" + sha256).decode()

print(cidv0(b"hello world"))
# QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpvBw3cWE69N3T

Denne CID kan gengives af hvem som helst — kør den samme kode med de samme bytes hvor som helst i verden, og du får den samme streng. Det er content addressing.

Node.js-ækvivalent:

import { sha256 } from 'multiformats/hashes/sha2';
import { CID } from 'multiformats/cid';

const bytes = new TextEncoder().encode('hello world');
const hash = await sha256.digest(bytes);
const cid = CID.create(1, 0x55, hash); // version 1, raw codec
console.log(cid.toString());
// bafkreif7l7mvyofhyo6fgs6mjf5gguvm5jcahzgvfb3o7t5lmhz3...

Hvad er en IPFS CID?#

En Content Identifier (CID) er et unikt fingeraftryk, der repræsenterer et stykke indhold på IPFS. I modsætning til traditionelle web-URL’er, der peger på en placering (som https://example.com/file.pdf), peger CIDs på selve indholdet, uanset hvor det er gemt.

Tænk på det sådan:

Placeringsbaseret adressering: “Gå til Hovedgaden 123 og bed om den røde bog”
Indholdsbaseret adressering: “Find bogen med ISBN 978-0-123456-78-9” (hvilket bibliotek der har den, betyder ikke noget)

CIDs virker på samme måde — de identificerer indhold baseret på dets kryptografiske hash, hvilket gør indholdet uforanderligt og verificerbart. Hvis en enkelt byte ændres i filen, ændres CID’en helt.

Hvorfor content-adressering er vigtig#

Traditionel webarkitektur er afhængig af placeringsbaseret adressering. Når du besøger https://example.com/image.jpg, stoler du på, at:

Domæneejeren ikke har ændret indholdet
Serveren er online og tilgængelig
Indholdet ikke er blevet manipuleret

Med content-adressering ved hjælp af CIDs:

Uforanderlighed: CID’en garanterer, at indholdet ikke er ændret
Decentralisering: Indhold kan hentes fra enhver IPFS-node, der har det
Verifikation: Du kan kryptografisk verificere, at du har modtaget det korrekte indhold
Effektivitet: Identisk indhold dedupliceres automatisk

Anatomien af en CID#

Lad os bryde en typisk CID ned for at forstå dens komponenter:

bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
└─┬─┘└─────────────────┬─────────────────────────────────┘
  │                   │
  │                   └─ Indholdshash (Base32-kodet)
  └─ Multibase præfiks (angiver kodning)

En CID indeholder flere informationsstykker:

1. Multibase præfiks#

Det første tegn angiver, hvordan CID’en er kodet:

Q = Base58 kodning (CIDv0)
b = Base32 kodning (CIDv1)
f = Base16/heksadecimal (CIDv1)
z = Base58 (CIDv1)

2. CID-version#

CIDv0: Starter altid med Qm, bruger SHA-256, begrænset til DAG-PB codec
CIDv1: Mere fleksibel, understøtter flere hash-funktioner og codecs

3. Multicodec#

Specificerer, hvordan indhold er struktureret (DAG-PB, DAG-CBOR, rå bytes, osv.)

4. Multihash#

Den faktiske kryptografiske hash af indholdet, inklusive:

Hash-funktionsidentifikator (normalt SHA-256)
Hash-længde
Hash-digesten

CIDv0 vs CIDv1: Forståelse af forskellene#

IPFS har udviklet sig gennem to store CID-versioner, hver med distinkte karakteristika:

CIDv0: Det oprindelige format#

CIDv0 CIDs starter altid med Qm og ser sådan ud:

QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG

Karakteristika:

Kun Base58 kodning
Kun SHA-256 hash-funktion
Kun DAG-PB (Protobuf) codec
46 tegn lang
Bagudkompatibel med alle IPFS-implementeringer

Hvornår skal man bruge CIDv0:

Maksimal kompatibilitet med ældre IPFS-noder
Arbejde med eksisterende systemer, der forventer Qm præfiks
Filopbevaring (mest almindelige brugsscenarie)

CIDv1: Den moderne standard#

CIDv1 CIDs er mere fleksible og kan se sådan ud:

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

Karakteristika:

Flere kodningsformater (Base32, Base58, Base16)
Understøttelse af forskellige hash-funktioner (SHA-256, SHA-512, BLAKE2, osv.)
Flere codecs (Raw, DAG-CBOR, DAG-JSON, osv.)
Selvbeskrivende format
Ikke case-sensitiv ved Base32 brug

Hvornår skal man bruge CIDv1:

Bygge nye applikationer
Behov for case-insensitive identifikatorer
Arbejde med struktureret data (JSON, CBOR)
Bruge alternative hash-funktioner

Konvertering mellem versioner#

Du kan konvertere CIDs mellem versioner, samtidig med at du bevarer den samme indholdsreference:

// CIDv0
const cidv0 = "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG";

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

// Both reference the same content!

Hvordan content-adressering virker#

Content-adressering i IPFS følger en deterministisk proces, der sikrer, at det samme indhold altid producerer den samme CID:

1. Indholdsforberedelse#

Når du tilføjer indhold til IPFS, bliver det først brudt ned:

Små filer: Gemmes som enkelte blokke
Store filer: Opdeles i bidder og organiseres i en Merkle DAG (rettet acyklisk graf)
Mapper: Repræsenteres som DAG-strukturer, der linker til filer

2. Hashing-processen#

Hvert stykke indhold gennemgår:

Serialisering: Indhold formateres ifølge sin codec
Hashing: Kryptografisk hash-funktion behandler den serialiserede data
Multihash-oprettelse: Hash pakkes med algoritme- og længdeinformation
CID-samling: Version, codec og multihash kombineres

3. Merkle DAG-struktur#

IPFS organiserer indhold i en Merkle DAG, hvor:

Hver node har en CID
Forældernoder refererer til underordnede noder via CID
Ændringer i enhver node forplanter sig op gennem træet
Hele strukturer kan kryptografisk verificeres

Root CID: bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
├── file1.txt (QmHash1...)
├── file2.jpg (QmHash2...)
└── subdirectory/
    ├── file3.pdf (QmHash3...)
    └── file4.mp4 (QmHash4...)

Praktiske eksempler: Arbejde med CIDs#

Lad os udforske, hvordan man arbejder med CIDs i praksis ved hjælp af IPFS Ninja API:

Upload indhold 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 indhold med CID#

Hvis du allerede har en CID, kan du pinne den for at sikre tilgængelighed:

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

Adgang til indhold via CID#

Når du har en CID, kan du få adgang til indholdet via forskellige 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-bedste praksis for udviklere#

1. Valider altid CIDs#

Før du bruger en CID i din applikation, valider dens 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. Håndter begge CID-versioner#

Din applikation bør virke 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-mapninger#

Hvis du genererer CIDs ofte, overvej 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. Brug meningsfulde beskrivelser#

Når du uploader indhold, 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'
      }
    })
  });
};

Almindelige CID-brugsscenarier#

1. Statisk hjemmeside-deployment#

Deploy hele hjemmesider til IPFS og reference 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 at lære mere om hjemmeside-deployment, tjek vores guide om hvordan man uploader filer til IPFS.

2. NFT-metadataopbevaring#

Opbevar NFT-metadata uforanderligt ved hjælp af 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. Content-distribution#

Brug CIDs til distribueret content-levering:

// 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åelse af IPFS-pinning med CIDs#

CIDs er midlertidige som standard — de skal “pinnes” for at forblive tilgængelige. Lær mere om dette afgørende koncept i vores omfattende guide om hvad IPFS-pinning er.

Når du vælger en IPFS-pinningstjeneste, overvej at læse vores IPFS Ninja vs Pinata sammenligning eller udforsk vores oversigt over de bedste IPFS-pinningstjenester, der er tilgængelige i dag.

Opret din første CID på 30 sekunder#

Klar til at generere din første CID? Her er et hurtigt eksempel ved hjælp af 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 noget som:

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

For mere detaljerede API-eksempler, se vores IPFS upload-API tutorial.

Konklusion#

CIDs er fundamentet for IPFS’ content-adresseringssystem, der giver uforanderlig, verificerbar og decentraliseret indholdsidentifikation. At forstå, hvordan de virker — fra de tekniske detaljer ved CIDv0 vs CIDv1 til praktiske implementeringsmønstre — er essentielt for at bygge robuste decentraliserede applikationer.

Vigtige punkter:

CIDs identificerer indhold unikt, ikke placeringer
CIDv0 giver maksimal kompatibilitet, CIDv1 tilbyder fleksibilitet
Content-adressering muliggør verifikation og deduplikering
Korrekt CID-håndtering er afgørende for produktionsapplikationer

Uanset om du opbevarer NFT-metadata, deployer decentraliserede hjemmesider eller bygger content-distributionssystemer, giver CIDs den pålidelige fundament, du har brug for til virkelig decentraliserede applikationer.

Klar til at begynde at pinne? Opret en gratis konto — 50 filer, 1 GB lagerplads, 2 GB båndbredde/måned. Intet kreditkort kræves.