VPC আর subnet — CIDR, public-private আর ঠিকানার নকশা

১ · VPC কী — cloud-এর ভেতরে নিজের আবাসিক এলাকা

একটি বড় আবাসিক এলাকা ভাবুন। সীমানার ভেতরে রাস্তা, ব্লক আর বাড়ির নম্বর সব এলাকার নিজের ঠিক করা। মূল গেট কোথায় হবে, কোন ব্লকে বাইরের মানুষ ঢুকতে পারবে, আর কোন ব্লকে শুধু বাসিন্দারা, তাও এলাকার সমিতিই ঠিক করে। পাশের এলাকাতেও “রোড ৫, বাড়ি ১২” থাকতে পারে; কেউ বিভ্রান্ত হয় না, কারণ দুই এলাকার মধ্যে সরাসরি রাস্তা নেই।

VPC (Virtual Private Cloud) cloud-এর ভেতরে এমনই একটি এলাকা। এটি আপনার নিজের virtual network: ঠিকানার পরিসর আপনি বাছেন, সেটিকে subnet নামের ব্লকে ভাগ করেন, আর ঠিক করেন packet কোন পথে যাবে। পর্ব ১৫-এর VM, পর্ব ১৮-এর load balancer আর পর্ব ২২-এর database, সবই কোনো না কোনো subnet-এ বসে। এই মডিউলের ছয়টি পর্বে আমরা সেই network-টিই গড়ব।

ভেতরে কোনো আলাদা switch বা তার আপনার জন্য বসানো হয় না। VPC হলো software-defined network: নিয়মগুলো একটি control plane-এ লেখা থাকে, আর hypervisor-এর সফটওয়্যার প্রতিটি packet-কে সেই নিয়মে চালায়। আপনার packet একটি বাইরের খামে মুড়ে provider-এর সাধারণ network দিয়ে যায়; এই কৌশলকে বলে overlay network. তাই একই 10.20.0.5 ঠিকানা দুই গ্রাহকের দুই VPC-তে থাকতে পারে। নিয়ন্ত্রণ আলাদা করার ধারণাটি পাবেন Computer Networks-এর SDN পর্বে, আর সারসংক্ষেপ cloud আর container নেটওয়ার্কিং পর্বে। এখানে আমাদের প্রশ্ন একটিই: ঠিকানা সাজাবেন কীভাবে?

এই টেবিল লেখার সময়ের সাধারণ চিত্র; কাজে নামার আগে নিজের provider-এর নথি দেখে নিন। বিশেষ করে Google-এর একটি VPC একাধিক region-এ subnet রাখতে পারে, তাই “VPC প্রতি region-এ একটি” ধরে নিলে ওখানে নকশা মিলবে না।

২ · CIDR-এর ঝটপট ঝালাই আর RFC 1918

Binary subnetting-এর পুরো তত্ত্ব আছে Computer Networks-এর subnetting পর্বে। এখানে দুই লাইনের ঝালাই। CIDR লেখায় 10.20.0.0/16 মানে প্রথম ১৬ bit network-এর, বাকি ১৬ bit host-এর। মোট bit ৩২, তাই ঠিকানা = 2^32−p, যেখানে p হলো prefix.

Prefix এক বাড়লে ঠিকানা অর্ধেক হয়, এক কমলে দ্বিগুণ। এটুকু মনে থাকলে বাকি হিসাব সহজ।

কোন পরিসর থেকে বাছবেন

VPC-র ঠিকানা সাধারণত private IP পরিসর থেকে নেওয়া হয়। RFC 1918 (ফেব্রুয়ারি ১৯৯৬) তিনটি পরিসর ইন্টারনেটের বাইরে ভেতরের ব্যবহারের জন্য আলাদা করে রেখেছে। এগুলো ইন্টারনেটে route হয় না, তাই সবাই ব্যবহার করতে পারে। মূল্য হলো: এগুলো পৃথিবীতে অনন্য নয়।

নিচের calculator যেকোনো CIDR-এর মাপ, mask আর পরিসর বের করে। list-এ নিজের CIDR বসিয়ে চালান। খেয়াল করুন, ঠিকানার সংখ্যা হিসাব করতে এখানে bit shift ব্যবহার হয়নি, কারণ JavaScript-এর << ৩২-bit signed সংখ্যায় কাজ করে আর বড় ঠিকানায় মান ঋণাত্মক হয়ে যায়।

// CIDR calculator: size, mask, range and usable addresses.
// Plain arithmetic, because JS << works on signed 32-bit numbers.
const toInt = s => s.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const toIp = n => [24, 16, 8, 0].map(b => Math.floor(n / 2 ** b) % 256).join(".");

function info(cidr) {
  const [base, p] = cidr.split("/");
  const size = 2 ** (32 - Number(p)), ip = toInt(base);
  const first = ip - (ip % size);                 // clear the host bits
  return { size, first, last: first + size - 1, mask: toIp(2 ** 32 - size) };
}
const usable = (size, r) => (size > r ? size - r : "none");

console.log("cidr             addresses  mask              range");
const list = ["10.20.0.0/16", "10.20.0.0/20", "10.20.16.0/24",
              "10.20.16.0/26", "10.20.16.0/28", "10.20.37.5/20"];
for (const c of list) {
  const x = info(c);
  console.log(c.padEnd(16), String(x.size).padStart(9), "", x.mask.padEnd(16),
              toIp(x.first), "..", toIp(x.last));
}
console.log("\nprefix  reserve 5  reserve 4");   // AWS and Azure 5, Google 4 (check docs)
for (const p of [16, 20, 24, 26, 28, 30]) {
  const s = 2 ** (32 - p);
  console.log(`/${p}`.padEnd(7), String(usable(s, 5)).padStart(9), String(usable(s, 4)).padStart(10));
}
// Smallest subnet for a host count, with growth room and reserved addresses.
function fit(hosts, growthPct, reserved) {
  const need = Math.ceil(hosts * (100 + growthPct) / 100) + reserved;
  const prefix = 32 - Math.ceil(Math.log2(need));
  return `${hosts} hosts +${growthPct}% +${reserved} = ${need} -> /${prefix} (${2 ** (32 - prefix)})`;
}
console.log("\n" + [[500, 30, 5], [30, 50, 5], [2000, 50, 5]].map(a => fit(...a)).join("\n"));

cidr             addresses  mask              range
10.20.0.0/16         65536  255.255.0.0      10.20.0.0 .. 10.20.255.255
10.20.0.0/20          4096  255.255.240.0    10.20.0.0 .. 10.20.15.255
10.20.16.0/24          256  255.255.255.0    10.20.16.0 .. 10.20.16.255
10.20.16.0/26           64  255.255.255.192  10.20.16.0 .. 10.20.16.63
10.20.16.0/28           16  255.255.255.240  10.20.16.0 .. 10.20.16.15
10.20.37.5/20         4096  255.255.240.0    10.20.32.0 .. 10.20.47.255

prefix  reserve 5  reserve 4
/16         65531      65532
/20          4091       4092
/24           251        252
/26            59         60
/28            11         12
/30          none       none

500 hosts +30% +5 = 655 -> /22 (1024)
30 hosts +50% +5 = 50 -> /26 (64)
2000 hosts +50% +5 = 3005 -> /20 (4096)

৩ · VPC-র মাপ, কাটা ঠিকানা আর হাতে হিসাব

ঠিকানার মাপ বাছা বাড়ির জমি কেনার মতো। ছোট জমি কিনলে পরে ঘর বাড়ানো কঠিন। আবার অকারণে বিশাল জমি নিলে পাশের এলাকার সাথে সীমানা নিয়ে ঝগড়া বাধে। VPC-তে সমস্যাটি একই: খুব ছোট হলে ঠিকানা ফুরায়, খুব বড় হলে প্রতিষ্ঠানের ভাগের ঠিকানা শেষ হয় আর অন্য network-এর সাথে ঠোকাঠুকি বাড়ে।

এগুলো নিয়ম নয়, ধারণা। AWS-এ লেখার সময়ে একটি VPC CIDR /16 থেকে /28 পর্যন্ত হতে পারে; অন্য provider-এর সীমা আলাদা। আকার ঠিক করুন উল্টো দিক থেকে: আগে গুনুন কতগুলো subnet লাগবে।

প্রতি subnet-এ কাটা ঠিকানা

একটি subnet-এর সব ঠিকানা আপনার নয়। Provider কয়েকটি কেটে রাখে। AWS-এর উদাহরণে 10.20.0.0/20-এ পাঁচটি ঠিকানা যায়:

Azure-এও পাঁচটি যায়, তবে কাজের ভাগ একটু আলাদা। Google Cloud-এ সাধারণত চারটি যায়: প্রথম দুটি আর শেষ দুটি। পাঠ্যবইয়ের সূত্র 2^h − 2 cloud-এ সরাসরি খাটে না। আর /28-এর মতো ছোট subnet-এ এই পাঁচটি মানে ১৬-র প্রায় এক-তৃতীয়াংশ।

পাঁচটি numerical, পূর্ণ সমাধান

1. /20-এ কতটি? 2³²⁻²⁰ = 2¹² = ৪,০৯৬। AWS বা Azure-এ ব্যবহারযোগ্য ৪,০৯৬ − ৫ = ৪,০৯১, Google-এ ৪,০৯৬ − ৪ = ৪,০৯২।
2. /16 থেকে কতগুলো /20? ধার করা bit ২০ − ১৬ = ৪, তাই 2⁴ = ১৬টি। তৃতীয় octet-এ লাফ ২৫৬ ÷ ১৬ = ১৬: 10.20.0.0, 10.20.16.0, 10.20.32.0…
3. ৫০০ host, ৩০% বৃদ্ধি, AWS. ৫০০ × ১.৩ = ৬৫০; ৫টি যোগ করলে ৬৫৫। 2⁹ = ৫১২ ছোট, 2¹⁰ = ১,০২৪ যথেষ্ট। Host bit ১০, তাই prefix ৩২ − ১০ = /22.
4. 10.20.37.5 কোন /20-এ? Block ১৬। ৩৭ ÷ ১৬-র ভাগফল ২, আর ২ × ১৬ = ৩২। Network 10.20.32.0/20, পরিসর 10.20.47.255 পর্যন্ত।
5. 10.20.0.0/16 আর 10.20.128.0/17 কি মেলে? সংখ্যায় লিখি। প্রথমটি ১৬,৯০,৮২,৮৮০ থেকে ১৬,৯১,৪৮,৪১৫। দ্বিতীয়টি ১৬,৯১,১৫,৬৪৮ থেকে ১৬,৯১,৪৮,৪১৫। নিয়ম: lo₁ ≤ hi₂ আর lo₂ ≤ hi₁. দুটিই সত্য, তাই overlap.

৪ · Subnet কোথায় থাকে — zone নাকি region

পর্ব ৫-এ দেখেছেন, availability zone একটি region-এর ভেতরে আলাদা বিদ্যুৎ ও network-এর data center দল। Multi-AZ নকশায় অ্যাপের কপি একাধিক zone-এ থাকে। Subnet-এর সাথে zone-এর সম্পর্ক provider ভেদে দুই রকম, আর এটি ঠিকানার হিসাব সরাসরি বদলায়।

দুই ধরনেই নকশার নীতি একই: কোনো একটি zone পড়ে গেলে বাকি zone-এ চলার মতো জায়গা থাকতে হবে। এই পর্বের হিসাবে আমরা AWS-এর ধরন ধরছি, কারণ এতে subnet বেশি লাগে আর হিসাব কঠিন হয়। সহজ ধরনে কমিয়ে নেওয়া সহজ, উল্টোটা নয়।

৫ · Public, private আর isolated — subnet-কে কী public বানায়

সবচেয়ে প্রচলিত ভুল ধারণা হলো: subnet-এর নাম “public” রাখলেই সেটি public. নাম শুধু লেবেল। Subnet-এ কোনো “public” সুইচও থাকে না। পার্থক্য তৈরি করে তার সাথে জোড়া routing table, মানে packet বাইরে যাওয়ার পথ।

দুটি শর্ত একসাথে লাগে: route আর public IP. Public subnet-এর VM-এ public IP না থাকলে ইন্টারনেট থেকে তাকে পাওয়া যাবে না। Route না থাকলে public IP দিয়েও লাভ নেই। আর VM-এর নিজের network card-এ private IP-ই থাকে; public IP-কে তার সাথে সাধারণত provider-এর NAT মিলিয়ে দেয়। পুরো পথের হিসাব পর্ব ২৬-এ। “Public subnet” শব্দটিও মূলত AWS-এর নথির; Google বা Azure-এ VM-ভিত্তিক external IP আর route দিয়েই একই ফল আসে, এবং সেখানে ধারণাটি কম আনুষ্ঠানিক।

তিন স্তরের নকশা

বিয়েবাড়ির কথা ভাবুন। গেটে অতিথি আসেন, মঞ্চ আর খাবারের ঘর ভেতরে, আর রান্নাঘর একদম পেছনে, যেখানে অতিথি যান না, শুধু খাবার আসে। তিন স্তরের নকশা একই: Load balancer গেটে, app মাঝখানে, database পেছনে। প্রতিটি স্তর শুধু পরের স্তরের সাথে কথা বলে।

কোন কাজ কোন স্তরে যাবে? দুটি প্রশ্নেই বেশিরভাগ সিদ্ধান্ত হয়: বাইরের কেউ কি সরাসরি এর সাথে যোগাযোগ শুরু করবে? এটি কি নিজে বাইরে যাবে? নিচে ছয়টি কাজ পরপর যাচাই করুন।

৬ · কাল্পনিক দোকানের নকশা — 10.20.0.0/16 থেকে /20

একটি কাল্পনিক অনলাইন বাজার অ্যাপ এক region-এ চলবে। শর্ত: তিন AZ, তিন স্তর, প্রতিটি subnet-এ কয়েকশো থেকে কয়েক হাজার ঠিকানা। পরে চতুর্থ AZ বা নতুন স্তর আসতে পারে। স্তর × AZ-এর ঘর = ৩ × ৩ = ৯, কিন্তু ভবিষ্যতের জন্য আমরা ৪ স্তর × ৪ AZ = ১৬টি ঘর ধরব। ⌈log₂ ১৬⌉ = ৪ bit, তাই /16 + ৪ = /20.

নিচের planner একই নকশা হিসাব করে টেবিল ছাপে। VPC, TIER_P, SUB_P বা AZS বদলে নিজের নকশা চালান। জায়গায় না ধরলে এটি error দেবে, যা ভুল টেবিল ছাপার চেয়ে ভালো।

// VPC subnet planner: one /18 block per tier, one /20 per AZ inside each block.
// The fourth /20 of each block stays empty for a future AZ.
const VPC = "10.20.0.0/16", TIER_P = 18, SUB_P = 20, RES_FRONT = 4, RES_BACK = 1;
const TIERS = ["public", "private", "data"], AZS = ["a", "b", "c"];

const toInt = s => s.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const toIp = n => [24, 16, 8, 0].map(b => Math.floor(n / 2 ** b) % 256).join(".");
const [base, vp] = VPC.split("/");
const start = toInt(base), vpcSize = 2 ** (32 - Number(vp));
const tierSize = 2 ** (32 - TIER_P), subSize = 2 ** (32 - SUB_P);
const slots = tierSize / subSize;
if (TIERS.length * tierSize > vpcSize || AZS.length > slots) throw new Error("plan does not fit");

console.log("subnet     cidr            usable from    usable to      usable");
let used = 0;
TIERS.forEach((tier, i) => {
  const block = start + i * tierSize;
  AZS.forEach((az, j) => {
    const s = block + j * subSize;
    const from = s + RES_FRONT, to = s + subSize - 1 - RES_BACK;
    console.log(`${tier}-${az}`.padEnd(10), `${toIp(s)}/${SUB_P}`.padEnd(15),
                toIp(from).padEnd(14), toIp(to).padEnd(14), to - from + 1);
    used++;
  });
  console.log(`  held for ${tier}: ${toIp(block + AZS.length * subSize)}/${SUB_P}`);
});
const free = (vpcSize - used * subSize) / subSize;
const nextBlock = start + TIERS.length * tierSize;
const each = subSize - RES_FRONT - RES_BACK;
console.log(`\nsubnets: ${used} x /${SUB_P} = ${used * subSize} addresses`);
console.log(`usable : ${used} x ${each} = ${used * each}`);
console.log(`free   : ${free} x /${SUB_P} = ${free * subSize}`);
console.log(`next tier block: ${toIp(nextBlock)}/${TIER_P}`);

subnet     cidr            usable from    usable to      usable
public-a   10.20.0.0/20    10.20.0.4      10.20.15.254   4091
public-b   10.20.16.0/20   10.20.16.4     10.20.31.254   4091
public-c   10.20.32.0/20   10.20.32.4     10.20.47.254   4091
  held for public: 10.20.48.0/20
private-a  10.20.64.0/20   10.20.64.4     10.20.79.254   4091
private-b  10.20.80.0/20   10.20.80.4     10.20.95.254   4091
private-c  10.20.96.0/20   10.20.96.4     10.20.111.254  4091
  held for private: 10.20.112.0/20
data-a     10.20.128.0/20  10.20.128.4    10.20.143.254  4091
data-b     10.20.144.0/20  10.20.144.4    10.20.159.254  4091
data-c     10.20.160.0/20  10.20.160.4    10.20.175.254  4091
  held for data: 10.20.176.0/20

subnets: 9 x /20 = 36864 addresses
usable : 9 x 4091 = 36819
free   : 7 x /20 = 28672
next tier block: 10.20.192.0/18

এই নকশা তিন provider-এ তৈরির নমুনা নিচে। চালানোর দরকার নেই; পড়লেই চলবে। আইডিগুলো নমুনা। VPC নিজে সাধারণত খরচহীন হলেও NAT gateway আর public IP-তে টাকা লাগতে পারে, তাই নিজে পরীক্ষা করলে শেষে মুছে ফেলুন আর দাম provider-এর পাতায় দেখুন।

aws ec2 create-vpc --cidr-block 10.20.0.0/16
aws ec2 create-subnet --vpc-id vpc-0123456789abcdef0 \
  --cidr-block 10.20.0.0/20 --availability-zone ap-southeast-1a

az network vnet create --resource-group shop-rg --name shop-vnet \
  --address-prefixes 10.20.0.0/16
az network vnet subnet create --resource-group shop-rg \
  --vnet-name shop-vnet --name public --address-prefixes 10.20.0.0/20

gcloud compute networks create shop-vpc --subnet-mode=custom
gcloud compute networks subnets create public-1 --network=shop-vpc \
  --range=10.20.0.0/20 --region=asia-southeast1

Azure আর Google-এর নমুনায় একটি subnet-ই region জুড়ে থাকে, তাই সেখানে AZ-প্রতি /20 না করে স্তর-প্রতি একটি বড় subnet নেওয়াই বেশি স্বাভাবিক। হাতে CIDR না লিখে Terraform-এর cidrsubnet("10.20.0.0/16", 4, 6) ফাংশনে ঘরের নম্বর দিয়ে হিসাব করানো যায়; এটি দেয় 10.20.96.0/20, মানে private-c. Terraform আসবে পর্ব ৫২-তে।

৭ · বৃদ্ধির পরিকল্পনা আর Kubernetes-এর IP ক্ষুধা

Subnet-এর মাপ বেশিরভাগ provider-এ পরে সহজে বদলানো যায় না। AWS-এ subnet-এর CIDR বদলানো যায় না; মুছে নতুন বানাতে হয়, আর ভেতরের সব কিছু সরাতে হয়। Google-এ subnet বড় করা যায়, ছোট নয়। তাই আগে থেকেই ভাবুন: VPC-তে একটি secondary CIDR পরে যোগ করা অনেক provider-এ সম্ভব, কিন্তু সেটি জরুরি পথ, নকশার বিকল্প নয়।

VM গোনা সহজ। ঝামেলা বাধায় container. Kubernetes-এর নকশায় প্রতিটি pod নিজের IP পায় (বিস্তারিত পর্ব ৪৩-এ)। কোথা থেকে পাবে, তা ঠিক করে CNI plugin. AWS-এর VPC CNI-র মতো নকশায় pod সরাসরি VPC-র ঠিকানা পায়, আর দ্রুত চালু হওয়ার জন্য node আগে থেকেই কিছু warm IP ধরে রাখে। ফলে দশটি VM-এর জায়গায় হঠাৎ শতাধিক ঠিকানা উধাও। মোট হিসাব:

এবার দেখুন একটি IP সংকট কীভাবে আসে। একটি কাল্পনিক দল 10.30.1.0/24 subnet-এ cluster চালাচ্ছে, ব্যবহারযোগ্য ঠিকানা ২৫১। ধরে নিই node-প্রতি warm IP ১০টি। আসল সংখ্যা CNI-র setting আর version-ভেদে আলাদা।

100.64.0.0/10 হলো shared address space (RFC 6598, ২০১২), যা মূলত carrier-grade NAT-এর জন্য রাখা। কিছু provider pod-এর জন্য এটি ব্যবহারের পথ দেখায়, কারণ এটি সাধারণত অফিসের network-এ থাকে না। তবে কিছু network-এ থাকতে পারে, আর এই পরিসরের pod-কে অফিস থেকে সরাসরি পাওয়া না-ও যেতে পারে। আগে যাচাই করুন।

Provider-ভেদে নকশা আলাদা। GKE-র VPC-native cluster-এ সাধারণত pod-এর জন্য subnet-এর secondary range থাকে, আর প্রতি node একটি ছোট block পায়; default হিসেবে /24-এর কথা নথিতে পাওয়া যায়। Azure CNI Overlay-তে pod VNet-এর বাইরের আলাদা পরিসরে থাকে। Kubernetes-এর Service CIDR-ও (পর্ব ৪৫) আলাদা একটি পরিসর, আর সেটিও VPC বা অফিসের সাথে মিলতে দেওয়া যাবে না।

৮ · Overlap এড়ানো — VPC, অফিস আর peering

দুটি ভিন্ন গ্রামে একই নামের “রহিম মিয়া” থাকলে সমস্যা নেই। সমস্যা শুরু হয় দুই গ্রাম এক ইউনিয়নে মিশলে আর চিঠিতে শুধু নাম লেখা থাকলে। Network-এও তাই। দুটি VPC আলাদা থাকলে একই CIDR চলে। কিন্তু peering, VPN বা on-premises অফিসের সাথে জোড়া দিলে router বুঝতে পারে না 10.20.5.9 কোন দিকে পাঠাবে। সাধারণত provider এমন peering নিজেই নাকচ করে।

দ্বিতীয় লাইনটি একটি সুন্দর সত্য। প্রতিটি CIDR block তার নিজের মাপের গুণিতকে শুরু হয়, তাই দুটি block অর্ধেক মিলতে পারে না। নিচের checker আটটি network-এর ২৮ জোড়া মিলিয়ে দেখে, তারপর পরের খালি /16 খোঁজে। default-vpc-র 172.31.0.0/16 হলো AWS-এর default VPC-র পরিচিত পরিসর, আর docker0-র 172.17.0.0/16 হলো Docker bridge-এর সাধারণ default.

// Overlap checker: every pair of networks, then the next free /16.
const toInt = s => s.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const toIp = n => [24, 16, 8, 0].map(b => Math.floor(n / 2 ** b) % 256).join(".");
function parse(name, cidr) {
  const [base, p] = cidr.split("/");
  const size = 2 ** (32 - Number(p)), lo = toInt(base);
  if (lo % size !== 0) throw new Error(`${cidr}: host bits are set`);
  return { name, cidr, size, lo, hi: lo + size - 1 };
}
const nets = [
  ["shop-prod",   "10.20.0.0/16"],
  ["shop-stage",  "10.21.0.0/16"],
  ["analytics",   "10.20.128.0/17"],
  ["office-vpn",  "192.168.10.0/24"],
  ["partner",     "172.16.0.0/12"],
  ["default-vpc", "172.31.0.0/16"],
  ["docker0",     "172.17.0.0/16"],
  ["pods",        "100.64.0.0/16"],
].map(([n, c]) => parse(n, c));

const overlaps = (a, b) => a.lo <= b.hi && b.lo <= a.hi;
let clashes = 0;
for (let i = 0; i < nets.length; i++) for (let j = i + 1; j < nets.length; j++) {
  const a = nets[i], b = nets[j];
  if (!overlaps(a, b)) continue;
  const [big, small] = a.size >= b.size ? [a, b] : [b, a];
  console.log(`CLASH ${big.name} ${big.cidr} contains ${small.name} ${small.cidr}`);
  console.log(`      shared addresses: ${small.size}`);
  clashes++;
}
console.log(`checked ${nets.length * (nets.length - 1) / 2} pairs, ${clashes} clashes`);
// Search upward from 10.20.0.0 for a /16 that touches nothing.
let c = parse("candidate", "10.20.0.0/16");
while (nets.some(n => overlaps(n, c))) c = parse("candidate", `${toIp(c.lo + c.size)}/16`);
console.log(`next free /16: ${c.cidr}`);

CLASH shop-prod 10.20.0.0/16 contains analytics 10.20.128.0/17
      shared addresses: 32768
CLASH partner 172.16.0.0/12 contains default-vpc 172.31.0.0/16
      shared addresses: 65536
CLASH partner 172.16.0.0/12 contains docker0 172.17.0.0/16
      shared addresses: 65536
checked 28 pairs, 3 clashes
next free /16: 10.22.0.0/16

প্রতিষ্ঠানের পুরো ঠিকানার ছক

একটি VPC ঠিক রাখা যথেষ্ট নয়। ঠিকানা ভাগ করতে হবে ওপর থেকে। 10.0.0.0/8-কে ১৬টি /12-তে ভাগ করা যায়, আর প্রতিটি /12 থেকে ১৬টি /16 আসে। ধরুন একটি /12 এক region-এর, আর তার /16-গুলো সেখানকার VPC-র। Production, staging আর development আলাদা জায়গা পায়। এই খাতা একটি শেয়ার করা spreadsheet দিয়ে শুরু হতে পারে, তবে বড় হলে IPAM টুল লাগে, যেমন provider-এর IPAM সেবা বা খোলা উৎসের NetBox. তাতে দুই দল একই পরিসর নিতে পারে না।

Overlap হয়ে গেলে পথ তিনটি: একটি পাশের ঠিকানা বদলানো (কষ্টকর, কিন্তু পরিষ্কার), মাঝখানে NAT বসিয়ে ঠিকানা অনুবাদ করা (কাজ চলে, জটিলতা স্থায়ী), অথবা private endpoint-এর মতো নির্দিষ্ট সেবা ভাগ করা (পর্ব ২৮)। তিনটির চেয়েই সস্তা হলো আগে দুই মিনিট মিলিয়ে নেওয়া। অফিসের VPN-এ বাসার 192.168.1.0/24-ও মাঝে মাঝে ঠোকাঠুকি বাধায়, তাই ওই পরিসর VPC-তে না নেওয়াই ভালো। Google-এর auto mode VPC নিজে থেকে 10.128.0.0/9 থেকে subnet বানায়; সব VPC একই পরিসর পায় বলে peering-এ ঠোকাঠুকি হতে পারে, তাই production-এ custom mode-ই নিরাপদ।

হিসাবের ভেতরটি দেখতে চাইলে নিচের Bash block চালান। এটি ঠিকানাকে ৩২-bit সংখ্যায় বদলায়: প্রথম octet ২৪ bit বাঁয়ে সরে, পরেরটি ১৬, তারপর ৮। এরপর mask দিয়ে AND করলে network বেরিয়ে আসে। Router-ও মূলত এই কাজই করে।

#!/usr/bin/env bash
# IPv4 <-> integer with shifts, then a subnet membership test.
set -euo pipefail

ip2int() {
  local a b c d
  IFS=. read -r a b c d <<< "$1"
  echo $(( (a << 24) | (b << 16) | (c << 8) | d ))
}
int2ip() {
  local n=$1
  printf '%d.%d.%d.%d\n' $(( (n >> 24) & 255 )) $(( (n >> 16) & 255 )) \
                         $(( (n >> 8) & 255 ))  $(( n & 255 ))
}
mask_of() { echo $(( (0xFFFFFFFF << (32 - $1)) & 0xFFFFFFFF )); }

ip=10.20.37.5; prefix=20
n=$(ip2int "$ip"); mask=$(mask_of "$prefix"); net=$(( n & mask ))
last=$(( net | (~mask & 0xFFFFFFFF) ))
echo "$ip = $n"
echo "mask /$prefix = $(int2ip "$mask")"
echo "network = $(int2ip "$net")"
echo "last    = $(int2ip "$last")"
echo "size    = $(( last - net + 1 ))"

echo "--- is it inside 10.20.32.0/20?"
want=$(ip2int 10.20.32.0)
for host in 10.20.32.0 10.20.47.255 10.20.48.1 10.21.37.5; do
  if (( ($(ip2int "$host") & mask) == want )); then r=yes; else r=no; fi
  printf '%-14s %s\n' "$host" "$r"
done

10.20.37.5 = 169092357
mask /20 = 255.255.240.0
network = 10.20.32.0
last    = 10.20.47.255
size    = 4096
--- is it inside 10.20.32.0/20?
10.20.32.0     yes
10.20.47.255   yes
10.20.48.1     no
10.21.37.5     no

৯ · IPv6 সংক্ষেপে — আর ঠিকানার অভাব থাকে না?

IPv6-এর ঠিকানা ১২৮ bit, আর তার বিস্তারিত আছে Computer Networks-এর IPv6 পর্বে। Cloud-এর চোখে চারটি জিনিস বদলায়:

• মাপের ভাবনা আলাদা: AWS-এর মতো provider VPC-কে সাধারণত /56 দেয়, আর প্রতিটি subnet /64 হয়। একটি /64-এ 2⁶⁴টি ঠিকানা, তাই host গোনার প্রশ্নই ওঠে না। ঠিকানা সাধারণত provider-এর দেওয়া, আপনার বাছা নয়।
• Public-private-এর অর্থ বদলায়: অনেক IPv6 ঠিকানা বিশ্বজুড়ে route হয়। তাই “private ঠিকানা” বলে আড়াল থাকে না; আড়াল আসে route আর firewall থেকে। শুধু বাইরে যাওয়ার জন্য AWS-এর আছে egress-only gateway.
• সাধারণত দুটি একসাথে চলে: Dual-stack মানে প্রতিটি resource-এ IPv4 আর IPv6 দুটিই। IPv4-এর নকশার দায় তাতে যায় না।
• IPv4-এর দাম একটি কারণ: AWS ২০২৪ সাল থেকে public IPv4 ঠিকানার জন্য আলাদা ঘণ্টাভিত্তিক দাম ধরে। তাই IPv6 এখন শুধু ঠিকানার নয়, বিলেরও প্রশ্ন। আসল দাম provider-এর পাতায় দেখুন।

১০ · AI-এর যুগে VPC-র নকশা — হিসাব যাচাই আপনার

AI কয়েক সেকেন্ডে পুরো VPC-র Terraform লিখে দেয়। দেখতেও গোছানো হয়। কিন্তু AI আপনার অফিসের CIDR, পুরোনো VPC বা অংশীদারের network চেনে না, যদি না আপনি বলে দেন। আর ঠিকানার ভুল পরে সারাতে subnet ভেঙে সব কিছু সরাতে হয়, তাই এই ভুলের দাম বেশি।

AI-এর নকশা প্রয়োগের আগে — চেকলিস্ট

• প্রতিটি CIDR নিজের calculator বা Python-এর ipaddress দিয়ে আবার হিসাব করেছি
• অফিস, অন্য VPC, partner, Docker আর Kubernetes-এর পরিসর মিলিয়ে overlap নেই
• Database subnet-এ ইন্টারনেটের route বা public IP নেই
• Inbound নিয়মে 0.0.0.0/0 শুধু load balancer-এর দরকারি port-এ
• সর্বোচ্চ pod ধরে subnet-এর হিসাব করেছি, আর খালি ঠিকানার alert আছে
• terraform plan পড়েছি, throwaway account-এ চালিয়েছি, budget alert আছে
• Prompt-এ কোনো account ID, key বা secret দিইনি