IPFS CID 2026: Satura adresācijas ceļvedis

Praktisks ceļvedis IPFS CID: CIDv0 pret CIDv1, satura adresācija, CID ģenerēšana Node.js un Python, integritātes pārbaude. Atjaunināts 2026. gadam.

Nacho Collautors Atjaunināts: 10 min lasīšanas
Praktisks ceļvedis IPFS CID: CIDv0 pret CIDv1, satura adresācija, CID ģenerēšana Node.js un Python, integritātes pārbaude. Atjaunināts 2026. gadam.
TL;DR
  • Ģenerējiet reproducējamu CID no jebkura faila baitiem — tāds pats saturs vienmēr rada tādu pašu jaucējvērtību.
  • Jaunām augšupielādēm izmantojiet CIDv1: tas ir Base32, mazie burti, un darbojas ar apakšdomēnu vārtejām; CIDv0 tā nedarbojas.
  • Viena mainīta baita dēļ failā tā CID pilnībā mainās, tāpēc manipulācijas ir uzreiz atklājamas.
  • Satura adresācija nozīmē, ka faili tiek identificēti pēc tā, kas tie ir, nevis pēc tā, kur tie tiek mitināti.

Ja jūs jebkad esat strādājis ar IPFS (InterPlanetary File System), iespējams, esat saskāries ar virknēm kā QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG vai bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi. Tās nav nejaušas muļķības — tās ir Content Identifiers (CIDs), IPFS satura adresēšanas sistēmas mugurkauls.

CIDs izpratne ir būtiska ikvienam, kurš veido uz IPFS, neatkarīgi no tā, vai jūs augšupielādējat failus, veidojat decentralizētas lietojumprogrammas vai īstenojat satura izplatīšanas sistēmas. Šis ceļvedis izskaidros visu, kas jums jāzina par IPFS CIDs, kā darbojas satura adresēšana un kā sākt tos izmantot savos projektos.

IPFS Ninja

Ģenerējiet CID 5 rindās (Python)#

Lūk, kā jūs pats varat ģenerēt CID:

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

Šo CID var atkārtot ikviens — palaidiet vēlreiz ar tiem pašiem baitiem jebkur pasaulē, un iegūsiet to pašu virkni. Tā darbojas satura adresēšana.

Node.js ekvivalents:

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

Kas ir IPFS CID?#

Content Identifier (CID) ir unikāls pirkstu nospiedums, kas pārstāv satura gabalu IPFS. Atšķirībā no tradicionālajiem tīmekļa URL adresēm, kas norāda uz atrašanās vietu (kā https://example.com/file.pdf), CIDs norāda uz pašu saturu, neatkarīgi no tā, kur tas tiek glabāts.

Domājiet par to šādi:

  • Atrašanās vietas adresēšana: „Dodieties uz Galveno ielu 123 un palūdziet sarkano grāmatu”
  • Satura adresēšana: „Atrodiet grāmatu ar ISBN 978-0-123456-78-9” (nav svarīgi, kurā bibliotēkā tā ir)

CIDs darbojas līdzīgi — tie identificē saturu, pamatojoties uz tā kriptogrāfisko hash, padarot saturu nemainīgu un pārbaudāmu. Ja failā mainās pat viens baits, CID pilnībā mainās.

Kāpēc satura adresēšana ir svarīga#

Tradicionālā tīmekļa arhitektūra balstās uz atrašanās vietas adresēšanu. Kad apmeklējat https://example.com/image.jpg, jūs uzticaties, ka:

  1. Domēna īpašnieks nav mainījis saturu
  2. Serveris ir tiešsaistē un pieejams
  3. Saturs nav manipulēts

Ar satura adresēšanu izmantojot CIDs:

  1. Nemainība: CID garantē, ka saturs nav mainījies
  2. Decentralizācija: Saturu var iegūt no jebkura IPFS mezgla, kuram tas ir
  3. Pārbaude: Jūs varat kriptogrāfiski pārbaudīt, ka saņēmāt pareizo saturu
  4. Efektivitāte: Identisks saturs tiek automātiski deduplicēts

CID anatomija#

Sadalīsim tipisku CID, lai saprastu tā komponentus:

bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
└─┬─┘└─────────────────┬─────────────────────────────────┘
  │                   │
  │                   └─ Satura Hash (Base32 kodēts)
  └─ Multibase priedēklis (norāda kodējumu)

CID satur vairākus informācijas elementus:

1. Multibase priedēklis#

Pirmā rakstzīme norāda, kā CID ir kodēts:

  • Q = Base58 kodējums (CIDv0)
  • b = Base32 kodējums (CIDv1)
  • f = Base16/heksadecimāls (CIDv1)
  • z = Base58 (CIDv1)

2. CID versija#

  • CIDv0: Vienmēr sākas ar Qm, izmanto SHA-256, ierobežots līdz DAG-PB codec
  • CIDv1: Elastīgāks, atbalsta vairākas hash funkcijas un codecs

3. Multicodec#

Norāda, kā saturs ir strukturēts (DAG-PB, DAG-CBOR, neapstrādāti baiti utt.)

4. Multihash#

Satura faktiskais kriptogrāfiskais hash, ieskaitot:

  • Hash funkcijas identifikatoru (parasti SHA-256)
  • Hash garumu
  • Hash digestu

CIDv0 vs CIDv1: Atšķirību izpratne#

IPFS ir attīstījies caur divām galvenajām CID versijām, katra ar atšķirīgām īpašībām:

CIDv0: Sākotnējais formāts#

CIDv0 CIDs vienmēr sākas ar Qm un izskatās šādi:

QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG

Īpašības:

  • Tikai Base58 kodējums
  • Tikai SHA-256 hash funkcija
  • Tikai DAG-PB (Protobuf) codec
  • 46 rakstzīmes garš
  • Atpakaļ saderīgs ar visām IPFS implementācijām

Kad lietot CIDv0:

  • Maksimāla saderība ar vecākiem IPFS mezgliem
  • Darbs ar esošajām sistēmām, kas sagaida Qm priedēkļus
  • Failu glabāšana (visizplatītākais lietošanas gadījums)

CIDv1: Modernais standarts#

CIDv1 CIDs ir elastīgāki un var izskatīties šādi:

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

Īpašības:

  • Vairāki kodēšanas formāti (Base32, Base58, Base16)
  • Atbalsts dažādām hash funkcijām (SHA-256, SHA-512, BLAKE2 utt.)
  • Vairāki codecs (Raw, DAG-CBOR, DAG-JSON utt.)
  • Pašaprakstošs formāts
  • Nav reģistrjutīgs, lietojot Base32

Kad lietot CIDv1:

  • Jaunu lietojumprogrammu veidošana
  • Nepieciešami reģistrnejutīgi identifikatori
  • Darbs ar strukturētiem datiem (JSON, CBOR)
  • Alternatīvu hash funkciju izmantošana

Pārveidošana starp versijām#

Jūs varat pārveidot CIDs starp versijām, saglabājot to pašu satura atsauci:

// CIDv0
const cidv0 = "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG";

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

// Both reference the same content!

Kā darbojas satura adresēšana#

Satura adresēšana IPFS ietver deterministisku procesu, kas nodrošina, ka viens un tas pats saturs vienmēr rada vienu un to pašu CID:

1. Satura sagatavošana#

Kad jūs pievienojat saturu IPFS, tas vispirms tiek sadalīts:

  • Mazi faili: Glabāti kā atsevišķi bloki
  • Lieli faili: Sadalīti gabaliņos un organizēti Merkle DAG (virzīts aciklisks grafs)
  • Direktorijas: Pārstāvētas kā DAG struktūras, kas savieno ar failiem

2. Hashing process#

Katrs satura gabals iziet caur:

  1. Serializāciju: Saturs tiek formatēts saskaņā ar tā codec
  2. Hashing: Kriptogrāfiska hash funkcija apstrādā serializētos datus
  3. Multihash izveidi: Hash tiek iesaiņots ar algoritma un garuma informāciju
  4. CID montāžu: Versija, codec un multihash tiek apvienoti

3. Merkle DAG struktūra#

IPFS organizē saturu Merkle DAG, kur:

  • Katram mezglam ir CID
  • Vecāku mezgli atsaucas uz bērnu mezgliem caur CID
  • Izmaiņas jebkurā mezglā izplatās uz augšu kokā
  • Veselas struktūras var kriptogrāfiski pārbaudīt
Root CID: bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi
├── file1.txt (QmHash1...)
├── file2.jpg (QmHash2...)
└── subdirectory/
    ├── file3.pdf (QmHash3...)
    └── file4.mp4 (QmHash4...)

Praktiski piemēri: Darbs ar CIDs#

Apskatīsim, kā strādāt ar CIDs praksē, izmantojot IPFS Ninja API:

Satura augšupielāde un CID iegūšana#

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

Esoša satura piespraušana pēc CID#

Ja jums jau ir CID, jūs varat to piespraust, lai nodrošinātu pieejamību:

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

Piekļuve saturam caur CID#

Kad jums ir CID, jūs varat piekļūt saturam dažādos veidos:

// 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 labākās prakses izstrādātājiem#

1. Vienmēr validējiet CIDs#

Pirms CID izmantošanas savā lietojumprogrammā validējiet tā formātu:

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. Apstrādājiet abas CID versijas#

Jūsu lietojumprogrammai jāstrādā gan ar CIDv0, gan ar 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. Saglabājiet CID kartējumus kešatmiņā#

Ja bieži ģenerējat CIDs, apsveriet kešošanu:

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. Izmantojiet jēgpilnus aprakstus#

Augšupielādējot saturu, iekļaujiet aprakstošus metadatus:

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

Bieži sastopami CID lietošanas gadījumi#

1. Statiskas tīmekļa vietnes izvietošana#

Izvietojiet veselas tīmekļa vietnes IPFS un atsaucieties uz tām pēc 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;
};

Lai uzzinātu vairāk par tīmekļa vietnes izvietošanu, skatiet mūsu ceļvedi par to, kā augšupielādēt failus IPFS.

2. NFT metadatu glabāšana#

Glabājiet NFT metadatus nemainīgi, izmantojot 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. Satura izplatīšana#

Izmantojiet CIDs sadalītai satura piegādei:

// 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 piespraušanas izpratne ar CIDs#

CIDs pēc noklusējuma ir pagaidu — tie ir „jāpiesprauž”, lai paliktu pieejami. Uzziniet vairāk par šo svarīgo koncepciju mūsu visaptverošajā ceļvedī par to, kas ir IPFS piespraušana.

Izvēloties IPFS piespraušanas pakalpojumu, apsveriet mūsu salīdzinājuma IPFS Ninja vs Pinata lasīšanu vai izpētiet mūsu apkopojumu par labākajiem IPFS piespraušanas pakalpojumiem, kas ir pieejami šodien.

Izveidojiet savu pirmo CID 30 sekundēs#

Vai esat gatavs ģenerēt savu pirmo CID? Šeit ir ātrs piemērs, izmantojot 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();

Tas atgriezīs kaut ko līdzīgu:

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

Detalizētākiem API piemēriem skatiet mūsu IPFS augšupielādes API pamācību.

Secinājums#

CIDs ir IPFS satura adresēšanas sistēmas pamats, nodrošinot nemainīgu, pārbaudāmu un decentralizētu satura identifikāciju. Izpratne par to, kā tie darbojas — no CIDv0 vs CIDv1 tehniskām detaļām līdz praktiskiem īstenošanas modeļiem — ir būtiska, lai veidotu spēcīgas decentralizētas lietojumprogrammas.

Galvenās atziņas:

  • CIDs unikāli identificē saturu, nevis atrašanās vietas
  • CIDv0 nodrošina maksimālu saderību, CIDv1 piedāvā elastību
  • Satura adresēšana ļauj pārbaudīt un dublikātus
  • Pareiza CID apstrāde ir izšķiroša ražošanas lietojumprogrammām

Neatkarīgi no tā, vai glabājat NFT metadatus, izvietojat decentralizētas tīmekļa vietnes vai veidojat satura izplatīšanas sistēmas, CIDs nodrošina uzticamu pamatu, kas jums nepieciešams patiesi decentralizētām lietojumprogrammām.

Vai esat gatavs sākt piespraušanu? Izveidojiet bezmaksas kontu — 50 failu, 1 GB krātuves, 2 GB joslas platums/mēn. Bez kredītkartes.

Nacho Coll

Par autoru

Founder & Engineer at IPFS.NINJA

Nacho founded IPFS.NINJA to make content-addressed storage feel as simple as an S3 PUT — a single API call, a permanent CID, no wallets or peer discovery to reason about. Writes about IPFS internals, decentralized storage patterns, and the pinning-service landscape from the operator side of the wire.

Atpakaļ uz Blogu

Saistītie raksti

IPFS veiktspēja: paātriniet failu iegūšanu ar gateway
Guides

IPFS veiktspēja: paātriniet failu iegūšanu ar gateway

2026. g. 29. jūn.6min lasīšanas
IPFS augšupielādes tokeni: Droša klienta augšupielāde
Guides

IPFS augšupielādes tokeni: Droša klienta augšupielāde

2026. g. 6. apr.11min lasīšanas
NFT metadatu glabāšana: Pilnīga IPFS rokasgrāmata NFT veidotājiem
Guides

NFT metadatu glabāšana: Pilnīga IPFS rokasgrāmata NFT veidotājiem

2026. g. 30. marts10min lasīšanas