· Nacho Coll · Guides  · 8 min lasīšanas

IPFS CID izskaidrots: kas tas ir un kā darbojas satura adresēšana

Skaidra tehniska IPFS Content Identifiers (CIDs) skaidrojums. Kā darbojas satura adresēšana, CID versijas un kā izveidot savu pirmo CID.

Skaidra tehniska IPFS Content Identifiers (CIDs) skaidrojums. Kā darbojas satura adresēšana, CID versijas un kā izveidot savu pirmo CID.

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

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.

Share:
Atpakaļ uz Blogu

Saistītie raksti

Skatīt visus rakstus »