Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi

Dalam dunia digital yang berubah dengan pantas hari ini, menyampaikan kandungan dengan cepat dan boleh dipercayai adalah lebih penting berbanding sebelum ini. Sama ada menstrim video definisi tinggi atau memastikan akses lancar kepada aplikasi web dinamik, kelajuan dan kecekapan penyampaian kandungan boleh membuat atau memecahkan pengalaman pengguna. Di tengah-tengah pengedaran yang lancar ini ialah Rangkaian Penghantaran Kandungan (CDN). Artikel ini meneroka kerumitan seni bina CDN, memecahkan komponennya untuk memahami cara CDN beroperasi. Kami juga akan menyelami pelaksanaan praktikal dengan contoh kod dalam Node.js dan Python untuk menunjukkan integrasi CDN.

Jadual Kandungan

1. Pengenalan
2. Apakah itu CDN?
3. Seni Bina CDN Tradisional
4. Menyahhimpunkan Seni Bina CDN
   • Pelayan Edge lwn. Pelayan Asal
   • Strategi Caching
   • Imbangan Beban
   • Resolusi DNS
   • Ciri Keselamatan
5. Bagaimana CDN Berfungsi
   • Aliran Permintaan
   • Mekanisme Caching
   • Penghantaran Kandungan
6. Melaksanakan Integrasi CDN
   • Menggunakan CDN dengan Node.js
   • Menggunakan CDN dengan Python
7. Ciri CDN Lanjutan
   • Fungsi Pengkomputeran Tepi dan Tanpa Pelayan
   • Analitis dan Pemantauan Masa Nyata
   • Peningkatan Protokol: HTTP/2 dan HTTP/3
8. Kelebihan dan Cabaran
9. Masa depan CDN
10. Kesimpulan
11. Rujukan

pengenalan

Rangkaian Penghantaran Kandungan (CDN) ialah wira internet moden yang tidak didendang, memastikan pengguna di seluruh dunia boleh mengakses kandungan digital dengan pantas dan boleh dipercayai. Dengan menyebarkan kandungan merentasi rangkaian pelayan yang tersebar secara geografi, CDN mengurangkan kependaman, mengurangkan penggunaan lebar jalur dan meningkatkan kepuasan pengguna secara keseluruhan. Memandangkan permintaan untuk penyampaian kandungan yang lebih pantas dan cekap meningkat, memahami cara CDN dibina dan berfungsi menjadi penting untuk pembangun dan perniagaan.

Apakah CDN?

Rangkaian Penghantaran Kandungan (CDN) ialah rangkaian pelayan teragih yang direka untuk menyampaikan kandungan web dan aset digital lain kepada pengguna berdasarkan lokasi geografi mereka, asal kandungan dan jenis pelayan penghantaran kandungan. Matlamat utama CDN adalah untuk meminimumkan kependaman dan menambah baik masa pemuatan dengan menyediakan kandungan daripada pelayan yang secara fizikal lebih dekat dengan pengguna akhir.

Fungsi Utama CDN:

• Caching Kandungan: Menyimpan salinan kandungan di berbilang lokasi untuk memastikan akses pantas.
• Pengimbangan Beban: Mengedarkan permintaan pengguna dengan cekap merentas berbilang pelayan untuk mengelakkan mana-mana pelayan tunggal daripada terharu.
• Keselamatan: Melindungi daripada serangan Distributed Denial of Service (DDoS) dan memastikan penghantaran data selamat.
• Pengoptimuman: Meningkatkan kelajuan penghantaran kandungan melalui teknik seperti pemampatan dan pengurangan.

Seni Bina CDN Tradisional

CDN tradisional terdiri daripada beberapa komponen utama yang bekerjasama untuk menyampaikan kandungan dengan cekap dan selamat:

1. Pelayan Asal: Pelayan utama tempat kandungan asal disimpan.
2. Pelayan Tepi: Pelayan teragih terletak lebih dekat dengan pengguna akhir yang menyimpan dan menghantar kandungan.
3. Pelayan DNS: Halakan permintaan pengguna ke pelayan tepi terdekat.
4. Pengimbang Beban: Edarkan trafik masuk merentas berbilang pelayan untuk mengelakkan lebihan beban.
5. Pelayan Proksi: Bertindak sebagai perantara untuk permintaan pelanggan yang mencari sumber daripada pelayan lain.

Menyahhimpunkan Seni Bina CDN

Untuk benar-benar memahami cara CDN beroperasi, adalah berguna untuk memecahkan seni binanya kepada komponen individu. Pendekatan ini menjelaskan peranan yang dimainkan oleh setiap bahagian dalam memastikan penyampaian kandungan yang cekap.

Pelayan Edge lwn Pelayan Asal

• Pelayan Asal: Ini ialah hab pusat di mana kandungan asal berada. Apabila pelayan tepi tidak mempunyai kandungan yang diminta dicache, ia menghubungi pelayan asal untuk mengambilnya.

• Pelayan Tepi: Diletakkan secara strategik merentas pelbagai lokasi geografi, pelayan tepi menyimpan kandungan cache lebih dekat dengan pengguna akhir, yang mengurangkan kependaman dengan ketara dan meningkatkan masa muat.

Strategi Caching

Caching ialah asas kefungsian CDN, menentukan cara dan tempat kandungan disimpan dan disajikan. Strategi caching biasa termasuk:

• Caching Kandungan Statik: Ini melibatkan penyimpanan sumber yang tidak berubah seperti imej, CSS dan fail JavaScript.

• Caching Kandungan Dinamik: Lebih kompleks dan melibatkan kandungan yang kerap berubah. Teknik seperti Edge Side Includes (ESI) digunakan untuk cache bahagian kandungan dinamik.

• Time-to-Live (TTL): Mentakrifkan tempoh kandungan kekal dicache sebelum dimuat semula. Biasanya, kandungan dinamik mempunyai TTL yang lebih pendek, manakala kandungan statik menikmati TTL yang lebih panjang.

Contoh Node.js: Menetapkan Pengepala Kawalan Cache

const express = require('express');
const app = express();

app.use('/static', express.static('public', {
  maxAge: '1y', // Cache static assets for one year
}));

app.get('/dynamic', (req, res) => {
  res.set('Cache-Control', 'no-cache');
  res.send('<h1>Dynamic Content</h1>');
});

app.listen(3000, () => console.log('Server running on port 3000'));

Rajah 2: Pengepala Kawalan Cache dalam Node.js

Pengimbangan Beban

Pengimbangan beban memastikan trafik masuk tersebar secara sama rata merentas berbilang pelayan, menghalang mana-mana pelayan tunggal daripada menjadi halangan. Teknik pengimbangan beban biasa termasuk:

• Round Robin: Mengedarkan permintaan secara berurutan.
• Sambungan Paling Kurang: Menghalakan trafik ke pelayan dengan sambungan aktif paling sedikit.
• Pencincangan IP: Berikan permintaan berdasarkan alamat IP pelanggan.

Contoh Python: Pengimbang Beban Mudah dengan Kelalang

const express = require('express');
const app = express();

app.use('/static', express.static('public', {
  maxAge: '1y', // Cache static assets for one year
}));

app.get('/dynamic', (req, res) => {
  res.set('Cache-Control', 'no-cache');
  res.send('<h1>Dynamic Content</h1>');
});

app.listen(3000, () => console.log('Server running on port 3000'));

Rajah 3: Pengimbang Beban Asas dalam Python

Resolusi DNS

Sistem Nama Domain (DNS) adalah penting untuk CDN kerana ia mengarahkan permintaan pengguna ke pelayan tepi terdekat. Apabila pengguna meminta kandungan, penyelesai DNS mengenal pasti pelayan kelebihan optimum berdasarkan faktor seperti kedekatan geografi dan beban pelayan semasa.

Ciri Keselamatan

CDN meningkatkan keselamatan melalui pelbagai mekanisme:

• Perlindungan DDoS: Menyerap dan mengurangkan serangan Penafian Perkhidmatan Teragih.
• Tembok Api Aplikasi Web (WAF): Menapis dan memantau trafik HTTP antara aplikasi web dan Internet.
• SSL/TLS: Menyulitkan data antara pengguna dan CDN, memastikan penghantaran selamat.

Bagaimana CDN Berfungsi

Memahami aliran kerja CDN membantu menerangkan cara komponen seni binanya berinteraksi untuk menyampaikan kandungan dengan cekap.

Aliran Permintaan

1. Permintaan Pengguna: Seorang pengguna mengakses tapak web atau aplikasi.
2. DNS Lookup: Permintaan mencetuskan pertanyaan DNS untuk menyelesaikan nama domain ke alamat IP.
3. Penghalaan ke Pelayan Edge: Berdasarkan respons DNS, pengguna diarahkan ke pelayan tepi terdekat.
4. Semakan Cache: Pelayan tepi menyemak sama ada kandungan yang diminta dicache.
   • Cache Hit: Kandungan dihantar terus kepada pengguna.
   • Cache Miss: Pelayan tepi mengambil kandungan daripada pelayan asal.
5. Penghantaran Kandungan: Kandungan disampaikan kepada pengguna dan pelayan tepi menyimpannya untuk permintaan masa hadapan.

Mekanisme Caching

Caching melibatkan penyimpanan salinan kandungan pada pelayan tepi untuk mempercepatkan penghantaran. CDN menentukan dasar caching berdasarkan pengepala seperti Cache-Control dan Expires. Kandungan dinamik memerlukan strategi caching yang lebih canggih, selalunya melibatkan caching separa atau penjanaan kandungan masa nyata.

Penghantaran Kandungan

Setelah dicache, penghantaran kandungan menjadi pantas kerana sumber disampaikan dari lokasi yang lebih dekat dengan pengguna. Kedekatan ini bukan sahaja mengurangkan kependaman tetapi juga memudahkan beban pada pelayan asal, memastikan skalabiliti semasa trafik meningkat.

Melaksanakan Integrasi CDN

Menyepadukan CDN ke dalam aplikasi anda boleh meningkatkan prestasi dan kebolehpercayaan dengan ketara. Berikut ialah beberapa contoh praktikal yang menunjukkan cara menyediakan dan menggunakan CDN dalam aplikasi Node.js dan Python.

Menggunakan CDN dengan Node.js

Aplikasi Node.js boleh disepadukan dengan CDN dengan mudah untuk menyediakan aset statik dengan cekap. Begini caranya untuk menyediakan pelayan Express yang mudah untuk menggunakan CDN untuk menyediakan fail statik.

const express = require('express');
const app = express();

app.use('/static', express.static('public', {
  maxAge: '1y', // Cache static assets for one year
}));

app.get('/dynamic', (req, res) => {
  res.set('Cache-Control', 'no-cache');
  res.send('<h1>Dynamic Content</h1>');
});

app.listen(3000, () => console.log('Server running on port 3000'));

Rajah 4: Pelayan Ekspres Menyajikan Fail Statik melalui CDN

Menyepadukan dengan Pembekal CDN

Untuk berhubung dengan penyedia CDN seperti Cloudflare atau AWS CloudFront, anda biasanya akan mengemas kini tetapan DNS anda untuk menghalakan domain anda ke CDN. Persediaan ini membolehkan CDN mengendalikan pengedaran kandungan anda. Berikut ialah contoh cara mengkonfigurasi AWS CloudFront dengan aplikasi Node.js:

from flask import Flask, request
import requests

app = Flask(__name__)

servers = ['http://localhost:5001', 'http://localhost:5002']
current = 0

@app.route('/')
def load_balance():
    global current
    server = servers[current]
    current = (current + 1) % len(servers)
    response = requests.get(server + request.path)
    return response.content

if __name__ == '__main__':
    app.run(port=5000)

Rajah 5: Mengubah hala ke Kandungan Dihoskan CDN dalam Node.js

Menggunakan CDN dengan Python

Aplikasi Python, terutamanya yang dibina dengan rangka kerja seperti Flask atau Django, juga boleh memanfaatkan CDN untuk menyediakan fail statik dan media dengan cekap.

Contoh Kelalang: Menyediakan Fail Statik melalui CDN

import Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi from './Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi.svg';
import './App.css';

function App() {
  return (
    <div classname="App">
      <header classname="App-header">
        <img src="%7BMenyahhimpun" seni bina rangkaian penghantaran kandungan: cara cdn berfungsi classname="App-Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi" alt="Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi">
        <p>
          Edit <code>src/App.js</code> and save to reload.
        </p>
        <a classname="App-link" href="https://reactjs.org" target="_blank" rel="noopener noreferrer">
          Learn React
        </a>
      </header>
    </div>
  );
}

export default App;

Rajah 6: Templat HTML Rujukan Aset dihoskan CDN

Kod Aplikasi Kelalang

const express = require('express');
const app = express();
const path = require('path');

const CDN_URL = 'https://your-cloudfront-distribution.cloudfront.net';

app.use('/static', express.static(path.join(__dirname, 'public'), {
  maxAge: '1d',
  setHeaders: (res, path) => {
    if (path.endsWith('.html')) {
      res.setHeader('Cache-Control', 'no-cache');
    }
  },
}));

app.get('/', (req, res) => {
  res.redirect(`${CDN_URL}/index.html`);
});

app.listen(3000, () => console.log('Server running on port 3000'));

Rajah 7: Aplikasi Kelalang Mengintegrasikan CDN untuk Fail Statik

Contoh Django: Mengkonfigurasi Fail Statik dengan CDN

Dalam Django, menyepadukan CDN melibatkan penetapan STATIC_URL untuk menghala ke CDN.

    <meta charset="UTF-8">
    <title>CDN Integration Example</title>
    <link rel="stylesheet" href="%7B%7B%20cdn_url%20%7D%7D/css/styles.css">


    <h1>Welcome to CDN-Integrated Flask App</h1>
    <img src="%7B%7B%20cdn_url%20%7D%7D/images/Menyahhimpun%20Seni%20Bina%20Rangkaian%20Penghantaran%20Kandungan:%20Cara%20CDN%20Berfungsi.png" alt="Logo">
    <script src="%7B%7B%20cdn_url%20%7D%7D/js/scripts.js"></script>

Jalankan arahan berikut untuk mengumpul fail statik:

from flask import Flask, render_template

app = Flask(__name__)

CDN_URL = 'https://your-cdn-domain.com/static'

@app.route('/')
def home():
    return render_template('index.html', cdn_url=CDN_URL)

if __name__ == '__main__':
    app.run(debug=True)

Rajah 8: Tetapan Django untuk Penyepaduan CDN

Ciri CDN Lanjutan

CDN moden menawarkan pelbagai ciri lanjutan yang melangkaui penyampaian kandungan asas, meningkatkan prestasi, keselamatan dan kebolehskalaan.

Pengkomputeran Tepi dan Fungsi Tanpa Pelayan

CDN semakin menyepadukan keupayaan pengkomputeran tepi, membolehkan pembangun menjalankan fungsi tanpa pelayan lebih dekat dengan pengguna akhir. Ini bukan sahaja mengurangkan kependaman tetapi juga membolehkan pemprosesan data masa nyata.

Contoh: Menggunakan Fungsi Tanpa Pelayan dengan AWS Lambda@Edge

Lambda@Edge membolehkan anda melaksanakan kod sebagai tindak balas kepada peristiwa yang dijana oleh CloudFront, seperti permintaan penonton atau respons asal. Berikut ialah contoh mudah fungsi Lambda yang mengubah suai pengepala HTTP untuk meningkatkan keselamatan:

const express = require('express');
const app = express();

app.use('/static', express.static('public', {
  maxAge: '1y', // Cache static assets for one year
}));

app.get('/dynamic', (req, res) => {
  res.set('Cache-Control', 'no-cache');
  res.send('<h1>Dynamic Content</h1>');
});

app.listen(3000, () => console.log('Server running on port 3000'));

Rajah 9: Fungsi AWS Lambda@Edge untuk Mengubah Suai Pengepala HTTP

Analitis dan Pemantauan Masa Nyata

CDN moden menyediakan papan pemuka analitik komprehensif yang menawarkan cerapan tentang corak trafik, prestasi cache dan ancaman keselamatan. Dengan menyepadukan analitis ini, perniagaan boleh membuat keputusan berdasarkan data untuk mengoptimumkan penyampaian kandungan.

Contoh Python: Mengambil Analitis CDN dengan AWS SDK

from flask import Flask, request
import requests

app = Flask(__name__)

servers = ['http://localhost:5001', 'http://localhost:5002']
current = 0

@app.route('/')
def load_balance():
    global current
    server = servers[current]
    current = (current + 1) % len(servers)
    response = requests.get(server + request.path)
    return response.content

if __name__ == '__main__':
    app.run(port=5000)

Rajah 10: Mengambil Metrik CDN dengan AWS SDK dalam Python

Penambahbaikan Protokol: HTTP/2 dan HTTP/3

CDN memanfaatkan protokol lanjutan seperti HTTP/2 dan HTTP/3 untuk meningkatkan prestasi melalui ciri seperti pemultipleksan, pemampatan pengepala dan pengurusan sambungan yang dipertingkatkan. Protokol ini mengurangkan kependaman dan meningkatkan kecekapan pemuatan sumber.

Contoh Node.js: Mendayakan HTTP/2 dalam Pelayan Ekspres

import Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi from './Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi.svg';
import './App.css';

function App() {
  return (
    <div classname="App">
      <header classname="App-header">
        <img src="%7BMenyahhimpun" seni bina rangkaian penghantaran kandungan: cara cdn berfungsi classname="App-Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi" alt="Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi">
        <p>
          Edit <code>src/App.js</code> and save to reload.
        </p>
        <a classname="App-link" href="https://reactjs.org" target="_blank" rel="noopener noreferrer">
          Learn React
        </a>
      </header>
    </div>
  );
}

export default App;

Rajah 11: Mendayakan HTTP/2 dalam Node.js dengan Express

Kelebihan dan Cabaran

Kelebihan CDN

• Kependaman Dikurangkan: Menyajikan kandungan daripada pelayan yang lebih dekat dengan pengguna mengurangkan masa yang diambil untuk data sampai kepada mereka.

• Skalabiliti: CDN mengendalikan jumlah trafik yang besar dengan mudah, menampung lonjakan tanpa menjejaskan prestasi.

• Keselamatan Dipertingkat: Ciri keselamatan terbina dalam melindungi daripada ancaman dan serangan web biasa.

• Kecekapan Kos: Memunggah trafik ke pelayan tepi mengurangkan kos lebar jalur dan mengurangkan beban pada pelayan asal.

Cabaran CDN

• Kerumitan Persediaan Awal: Mengkonfigurasi dan mengoptimumkan CDN memerlukan pemahaman yang kukuh tentang seni bina dan tetapannya.

• Ketidaksahihan Cache: Memastikan kandungan lapuk dimuat semula dengan segera boleh menjadi rumit, terutamanya untuk kandungan dinamik.

• Pergantungan kepada Pembekal: Bergantung pada penyedia CDN pihak ketiga boleh memperkenalkan kebergantungan yang mungkin tidak sejajar dengan keperluan aplikasi tertentu.

• Kos Mengikut Skala: Walaupun CDN menjimatkan kos sehingga satu tahap, volum trafik yang sangat tinggi boleh menyebabkan perbelanjaan yang besar, terutamanya dengan aplikasi intensif lebar jalur.

Masa depan CDN

Masa depan CDN sedang dibentuk oleh penyepaduan Internet of Things (IoT), pengkomputeran tepi dan teknologi Web3. Pendekatan terdesentralisasi mendapat momentum, menawarkan alternatif kepada model terpusat tradisional. Selain itu, kemajuan dalam pengkomputeran tepi membolehkan tugas pemprosesan yang lebih kompleks dimuatkan ke pelayan tepi, meningkatkan lagi prestasi dan keupayaan.

Aliran Muncul:

• Pengkomputeran Tepi Tanpa Pelayan: Menggabungkan seni bina tanpa pelayan dengan pengkomputeran tepi membolehkan pembangun menggunakan fungsi yang berjalan lebih dekat kepada pengguna, mengurangkan kependaman dan meningkatkan kebolehskalaan.

• Pengoptimuman Dipacu AI: Memanfaatkan kecerdasan buatan untuk meramal corak trafik, mengoptimumkan strategi caching dan meningkatkan langkah keselamatan dalam masa nyata.

• Integrasi Blockchain: Menggunakan blokiran untuk pengurusan CDN terpencar, ketelusan dalam penyampaian kandungan dan memberi insentif kepada penyertaan nod.

CDN Terpencar:

Rangkaian Penghantaran Kandungan Terpencar (dCDN) mengedarkan kandungan merentasi rangkaian nod yang dikendalikan oleh pelbagai peserta, dan bukannya bergantung pada pelayan tepi penyedia tunggal. Pendekatan ini meningkatkan daya tahan, mengurangkan pergantungan pada satu-satu titik kegagalan, dan selalunya memanfaatkan teknologi blockchain untuk penyelarasan dan insentif.

Contoh Web3:

• IPFS (InterPlanetary File System): Protokol rakan ke rakan yang direka untuk menjadikan web lebih pantas, selamat dan lebih terbuka dengan mengedarkan kandungan merentas pelbagai nod. IPFS mengenal pasti fail berdasarkan kandungannya dan bukannya lokasinya, memastikan bahawa sebaik sahaja fail ditambahkan, ia boleh diambil daripada berbilang nod.

• Filecoin: Dibina di atas IPFS, Filecoin memberi insentif kepada pengguna untuk menyediakan ruang storan sebagai pertukaran token. Ini mewujudkan rangkaian storan terpencar di mana kandungan disimpan secara berterusan dan boleh diperoleh semula daripada pelbagai nod.

• Arweave: Rangkaian storan terdesentralisasi yang menyediakan storan data kekal dengan memanfaatkan struktur seperti blockchain baru yang dipanggil Blockweave. Arweave memastikan kandungan kekal boleh diakses selama-lamanya tanpa bergantung pada pelayan berpusat.
  

const express = require('express');
const app = express();

app.use('/static', express.static('public', {
  maxAge: '1y', // Cache static assets for one year
}));

app.get('/dynamic', (req, res) => {
  res.set('Cache-Control', 'no-cache');
  res.send('<h1>Dynamic Content</h1>');
});

app.listen(3000, () => console.log('Server running on port 3000'));

Rajah 12: Contoh Kontrak Pintar Filecoin

Dalam contoh ini, kontrak pintar ringkas membenarkan pengguna memuat naik dan mendapatkan semula metadata fail, memautkannya kepada CID (Pengecam Kandungan) beralamat kandungan dalam IPFS.

Kesimpulan

Rangkaian Penghantaran Kandungan ialah tulang belakang infrastruktur internet moden, memastikan kandungan digital dihantar dengan pantas, selamat dan boleh dipercayai kepada pengguna di seluruh dunia. Dengan memecahkan seni bina CDN, kami telah memperoleh pemahaman yang lebih jelas tentang cara setiap komponen menyumbang kepada prestasi dan kecekapan keseluruhan. Mengintegrasikan CDN ke dalam aplikasi, sama ada dibina dengan Node.js atau Python, boleh meningkatkan pengalaman pengguna dengan ketara dengan mengurangkan kependaman dan menambah baik masa muat.

Memandangkan teknologi terus maju, begitu juga CDN. Mereka sedang berkembang untuk menawarkan peluang baharu untuk pengoptimuman dan desentralisasi. Peningkatan model CDN terdesentralisasi sejajar dengan penekanan yang semakin meningkat pada teknologi Web3, menyediakan alternatif yang berdaya tahan dan berskala kepada sistem terpusat tradisional. Sama ada melalui pembekal CDN yang mantap atau rangkaian terdesentralisasi yang inovatif, CDN akan kekal di barisan hadapan dalam mengoptimumkan dan melindungi penghantaran kandungan digital.

Rujukan

1. Apakah itu CDN? - Cloudflare
2. Dokumentasi AWS CloudFront
3. Tapak Web Rasmi Express.js
4. Dokumentasi Rasmi Flask
5. Django Dokumentasi
6. Tapak Web Rasmi IPFS
7. Tapak Web Rasmi Filecoin
8. Tapak Web Rasmi Arweave
9. IPFS lwn CDN - Satu Analisis
10. Dokumentasi AWS Lambda@Edge
11. HTTP/2 Diterangkan
12. Ikhtisar HTTP/3

Atas ialah kandungan terperinci Menyahhimpun Seni Bina Rangkaian Penghantaran Kandungan: Cara CDN Berfungsi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!