PHP-യിൽ IPv6-ൽ പ്രവർത്തിക്കുന്നു

ഞങ്ങൾക്ക് അടുത്തിടെ LIR സ്റ്റാറ്റസും /29 IPv6 ബ്ലോക്കും ലഭിച്ചു. തുടർന്ന് നിയുക്ത സബ്‌നെറ്റുകളുടെ ട്രാക്ക് സൂക്ഷിക്കേണ്ടതിന്റെ ആവശ്യകത ഉയർന്നു. ഞങ്ങളുടെ ബില്ലിംഗ് PHP-യിൽ എഴുതിയിരിക്കുന്നതിനാൽ, ഈ പ്രശ്‌നം അൽപ്പം പരിശോധിക്കേണ്ടതും IPv6-മായി പ്രവർത്തിക്കുന്നതിന്റെ കാര്യത്തിൽ ഈ ഭാഷ ഏറ്റവും സൗഹൃദപരമല്ലെന്ന് മനസ്സിലാക്കേണ്ടതുമാണ്. വിലാസങ്ങളും ശ്രേണികളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ ഉണ്ടാകുന്ന പ്രശ്നങ്ങൾക്കുള്ള ഞങ്ങളുടെ പരിഹാരമാണ് കട്ടിന് താഴെ. ഒരുപക്ഷേ ഏറ്റവും ഗംഭീരമായിരിക്കില്ല, പക്ഷേ അത് ജോലി ചെയ്യുന്നു.

ഒരു സിദ്ധാന്തം

നിരാകരണം. IPv6 എന്താണെന്നും അത് എന്താണ് വരുന്നതെന്നും നിങ്ങൾക്ക് പരിചിതമാണെങ്കിൽ, ഈ ഭാഗം നിങ്ങൾക്ക് ബോറടിച്ചേക്കാം. അല്ലായിരിക്കാം.

IPv6 വ്യാഖ്യാനം ആദ്യമായി കാണുന്ന ആളുകൾക്ക് അത് വളരെ ബുദ്ധിമുട്ടുള്ളതായി തോന്നിയേക്കാം. ഗംഭീരമായ ശേഷം 64.233.177.101 ഞങ്ങൾ പെട്ടെന്ന് അഭിമുഖീകരിക്കുന്നു 2607:f8b0:4002:c08::8b ഞങ്ങൾ ആശയക്കുഴപ്പത്തിലായേക്കാം. രണ്ടും യഥാക്രമം 32, 128 ബിറ്റുകളുടെ മനുഷ്യൻ വായിക്കാവുന്ന പ്രാതിനിധ്യം മാത്രമാണ്. ഏതൊരു ഐപി പാക്കറ്റിലും ഓരോ ബിറ്റിനും കർശനമായി സ്റ്റാൻഡേർഡ് ഉദ്ദേശ്യത്തോടെയുള്ള ഒരു തലക്കെട്ട് അടങ്ങിയിരിക്കുന്നു. തലക്കെട്ടുകളുടെ ഘടനയിലേക്ക് കൂടുതൽ ആഴത്തിൽ പോകാതെ, ഇതിൽ നിന്ന് നമ്മൾ എടുത്തുകളയേണ്ട ഒരു കാര്യം, IP വിലാസങ്ങളും ശ്രേണികളുമുള്ള പ്രവർത്തനങ്ങൾക്ക്, ബൈനറി മാത്തമാറ്റിക്സും ബിറ്റ്വൈസ് പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നത് പൊതുവെ സൗകര്യപ്രദമാണ്. അവ ഡാറ്റാബേസിൽ സൂക്ഷിക്കുന്നതും ഏറ്റവും സൗകര്യപ്രദമാണ് ബൈനറി(4) IPv4-നും ബൈനറി(16) IPv6-ന്.

സ്പർശിക്കേണ്ട മറ്റൊരു പ്രധാന വശം നെറ്റ്‌വർക്ക് മാസ്കുകളും CIDR നൊട്ടേഷനുമാണ്. CIDR എന്നത് ക്ലാസ്സ്‌ലെസ്സ് ഇന്റർ-ഡൊമെയ്ൻ റൂട്ടിംഗിന്റെ ചുരുക്കപ്പേരാണ് (ക്ലാസില്ലാത്ത അഭിസംബോധന). IP വിലാസത്തിന്റെ ഏത് ഭാഗമാണ് നെറ്റ്‌വർക്ക് പ്രിഫിക്‌സ് എന്നും ഈ നെറ്റ്‌വർക്കിനുള്ളിലെ നെറ്റ്‌വർക്ക് ഇന്റർഫേസിന്റെ വിലാസം ഏത് ഭാഗമാണെന്നും നിർണ്ണയിക്കുന്നതിൽ ഈ ആശയം ക്ലാസ് ആശയത്തെ മാറ്റിസ്ഥാപിച്ചു. പ്രായോഗികമായി, പ്രിഫിക്സുമായി ബന്ധപ്പെട്ട ആദ്യത്തെ n ബിറ്റുകൾ 1 ആയും ബാക്കിയുള്ളവ 0 ആയും സജ്ജമാക്കും.

മനുഷ്യന് മനസ്സിലാക്കാവുന്ന രൂപത്തിൽ, ഇത് രൂപത്തിൽ എഴുതിയിരിക്കുന്നു ip.add.re.ss/cidr. ഉദാഹരണത്തിന്, 64.233.177.0/24 ആദ്യത്തെ 24 ബിറ്റുകൾ പ്രിഫിക്‌സിനെ സൂചിപ്പിക്കുന്നുവെന്ന് സൂചിപ്പിക്കുന്നു. അവസാന 8 ബിറ്റുകൾ, ഹ്യൂമൻ റീഡബിൾ നൊട്ടേഷനിലെ അവസാന നമ്പർ എന്നും അറിയപ്പെടുന്നു, സബ്നെറ്റിനുള്ളിലെ വിലാസത്തെ പരാമർശിക്കുന്നു. കുറച്ച് വ്യായാമങ്ങൾ കൂടി. 64.233.177.101/32 и 2607:f8b0:4002:c08::8b/128 - ഒരു നിർദ്ദിഷ്ട വിലാസം. 2607:f8b0:4002:c08::/64 - ആദ്യത്തെ 64 ബിറ്റുകൾ (ആദ്യത്തെ 4 ഗ്രൂപ്പുകൾ) പ്രിഫിക്സാണ്, ബാക്കിയുള്ള 64 ബിറ്റുകൾ പ്രാദേശിക ഭാഗമാണ്. വഴിയിൽ, എൻട്രിയിലെ "::" കൊണ്ട് ആരെങ്കിലും ആശയക്കുഴപ്പത്തിലാണെങ്കിൽ, ഇരട്ട കോളൻ 0 അടങ്ങുന്ന വിഭാഗങ്ങളുടെ അനിയന്ത്രിതമായ എണ്ണം മാറ്റിസ്ഥാപിക്കുന്നു. വ്യാഖ്യാനത്തിൽ ഇത് ഒരിക്കൽ മാത്രമേ ദൃശ്യമാകൂ. മറ്റൊരു വാക്കിൽ, 2607:f8b0:4002:c08::8b = 2607:f8b0:4002:c08:0:0:0:8b.

ഇതിൽ നിന്നെല്ലാം നാം എന്താണ് പഠിക്കേണ്ടത്? ഒന്നാമതായി, ബൈനറി AND ഉം OR ഉം ഉപയോഗിച്ച് ആദ്യത്തെയും അവസാനത്തെയും സബ്‌നെറ്റ് വിലാസം ലഭിക്കും, ബൈനറി രൂപത്തിൽ മാസ്‌ക് അറിയുക. രണ്ടാമതായി, അടുത്ത സബ്‌നെറ്റ് വലുപ്പം (അതായത് CIDR ഉപയോഗിച്ച്) n 1 വരെ ചേർത്തുകൊണ്ട് കണക്കാക്കാം nബൈനറി പ്രാതിനിധ്യത്തിൽ ആ സ്ഥാനം. ബൈനറി എന്നതുകൊണ്ട് ഞാൻ ഉദ്ദേശിക്കുന്നത് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിന്റെ ഫലമാണ് പാക്ക് () и inet_pton() കൂടുതൽ ഉപയോഗവും ബിറ്റ്വൈസ് ഓപ്പറേറ്റർമാർ, ബൈനറി എന്നത് ബൈനറി സിസ്റ്റം പ്രാതിനിധ്യമാണ്, അത് ഇനിപ്പറയുന്ന രീതിയിൽ ലഭിക്കും. അടിസ്ഥാന_പരിവർത്തനം().

ചരിത്ര പശ്ചാത്തലംക്ലാസില്ലാത്ത അഭിസംബോധനയ്ക്ക് മുമ്പ് ക്ലാസ് വേർതിരിവ് ഉണ്ടായിരുന്നു. ആ വിദൂര വർഷങ്ങളിൽ, ഇത്രയധികം സബ്‌നെറ്റുകൾ ഉണ്ടാകുമെന്ന് ആരും സങ്കൽപ്പിച്ചില്ല; അവ ഇടത്തോട്ടും വലത്തോട്ടും വലിയ ബ്ലോക്കുകളായി വിതരണം ചെയ്തു: ക്ലാസ് എ - പ്രിഫിക്‌സ് ആദ്യത്തെ 8 ബിറ്റുകളാണ് (അതായത് ആദ്യ നമ്പർ), മുൻ‌നിര ബിറ്റ് 0; ക്ലാസ് ബി - ആദ്യ 16 (ആദ്യത്തെ രണ്ട് അക്കങ്ങൾ), ലീഡിംഗ് ബിറ്റുകൾ 10; ക്ലാസ് സി - ആദ്യത്തെ 24 ബിറ്റുകൾ, ലീഡിംഗ് ബിറ്റുകൾ 110. ഈ മുൻനിര ബിറ്റുകൾ ഒരു പ്രത്യേക ക്ലാസിന്റെ വിലാസം നൽകിയ ശ്രേണികൾ വ്യക്തമാക്കുന്നു: 0.0.0.0 - 127.255.255.255 എ ക്ലാസ്സിന്, 128.0.0.0 - 191.255.255.255 - ക്ലാസ് ബി, 192.0.0.0 - 223.255.255.255 - ക്ലാസ് സി. ഗ്രഹത്തിലുടനീളം ഇന്റർനെറ്റ് വ്യാപിച്ചപ്പോൾ, തങ്ങൾക്ക് അടയാളം നഷ്ടപ്പെട്ടുവെന്ന് റെഗുലേറ്റർമാർ മനസ്സിലാക്കി, 90 കളുടെ തുടക്കത്തിൽ അവർ ഒരു വർഗരഹിതമായ ആശയം വികസിപ്പിച്ചെടുത്തു, അത് ബന്ധിക്കാതിരിക്കാൻ സാധ്യമാക്കി. പ്രമുഖ ബിറ്റുകളിലേക്ക്. കുറച്ചുകൂടി വിശദമായി ഇതിൽ കാണാം, പറയൂ, മഹാനും എല്ലാം അറിയുന്നവനും.

നമുക്ക് പരിശീലനത്തിലേക്ക് പോകാം

പ്രായോഗികമായി, എനിക്ക് തോന്നിയതുപോലെ, മൂന്ന് ടാസ്ക്കുകൾ ഞങ്ങൾ നടപ്പിലാക്കും:

1. ശ്രേണിയുടെ ആദ്യത്തേയും അവസാനത്തേയും വിലാസം നേടുന്നു;
2. അടുത്തതായി നൽകിയിരിക്കുന്ന വലുപ്പ ശ്രേണി (CIDR) നേടുക;
3. ഒരു വിലാസം ഒരു ശ്രേണിയിൽ പെട്ടതാണോ എന്ന് പരിശോധിക്കുന്നു.

നടപ്പാക്കൽ IPv6-നായിരിക്കും, എന്നാൽ ആവശ്യമെങ്കിൽ, യുക്തി എളുപ്പത്തിൽ പൊരുത്തപ്പെടുത്താനാകും. എനിക്ക് ചില ആശയങ്ങൾ ലഭിച്ചു ഇവിടെ നിന്ന്, എന്നാൽ ഇത് കുറച്ച് വ്യത്യസ്തമായി നടപ്പിലാക്കി. കൂടാതെ, ഉദാഹരണങ്ങൾ ഇൻപുട്ട് പിശകുകൾ പരിശോധിക്കുന്നില്ല. അതിനാൽ, നമുക്ക് പോകാം.

ഞാൻ ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, ശ്രേണിയുടെ തുടക്കവും ബൈനറി സബ്നെറ്റ് മാസ്കും അറിഞ്ഞുകൊണ്ട്, ബിറ്റ്വൈസ് പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് ഒരു ശ്രേണിയുടെ ആദ്യത്തേയും അവസാനത്തേയും വിലാസം നിർണ്ണയിക്കാനാകും. അതനുസരിച്ച്, നമ്മൾ ആദ്യം ചെയ്യേണ്ടത് CIDR നെ ഒരു ബൈനറി മാസ്കാക്കി മാറ്റുക എന്നതാണ്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ അതിന്റെ ഹെക്സ് പ്രാതിനിധ്യം ശേഖരിച്ച് ഒരു ബൈനറി ഒന്നായി പാക്ക് ചെയ്യും.

function cidrToMask ($cidr) {
    $mask = str_repeat('f', ceil($cidr / 4));
    $mask .= dechex(4 * ($cidr % 4));
    $mask = str_pad($mask, 32, '0');
    return pack('H*', $mask);
}

വെല്ലുവിളി പായ്ക്ക് ('H*', $മാസ്ക്) ഹെക്സ് പ്രാതിനിധ്യം അതേ രീതിയിൽ പാക്ക് ചെയ്യുന്നു inet_pton(). വിളിക്കുമ്പോൾ മാത്രമാണ് വ്യത്യാസം പാക്ക് () എല്ലാ 0-കളും അവയുടെ സ്ഥലത്തായിരിക്കണം, കൂടാതെ മനുഷ്യർക്ക് വായിക്കാൻ കഴിയുന്ന എൻട്രിയിൽ നിന്ന് വ്യത്യസ്തമായി എൻട്രിയിൽ കോളണുകളൊന്നും ഉണ്ടാകരുത്.

ശ്രേണിയുടെ തുടക്കവും അവസാനവും കണക്കാക്കുക എന്നതാണ് അടുത്ത ഘട്ടം. ഇവിടെ സൂക്ഷ്മതകൾ ഉയർന്നുവരുന്നു. ബിറ്റ്വൈസ് പ്രവർത്തനങ്ങൾ പ്രോസസ്സറിന്റെ ബിറ്റ് കപ്പാസിറ്റിയാൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. അതനുസരിച്ച്, എന്റെ 32-ബിറ്റ് CubieTruck-ൽ, ഞാൻ ചിലപ്പോൾ എല്ലാത്തരം ടെസ്റ്റ് പാമ്പറിങ്ങിനും ഉപയോഗിക്കുന്നു, ഒരു ഓപ്പറേഷനിൽ വിലാസത്തിന്റെ എല്ലാ 128 ബിറ്റുകളും പ്രോസസ്സ് ചെയ്യുന്നത് സാധ്യമല്ല. എന്നിരുന്നാലും, അതിനെ 32 ബിറ്റുകളുടെ ഗ്രൂപ്പുകളായി വിഭജിക്കുന്നതിൽ നിന്ന് ഒന്നും നമ്മെ തടയുന്നില്ല (ഒരുപക്ഷേ, ഞങ്ങൾ ഏത് പ്രോസസ്സറിലാണ് പ്രവർത്തിക്കേണ്ടതെന്ന് ആർക്കറിയാം).

function getRangeBoundary ($ip, $cidr, $which, $ipIsBin = false, $returnBin = false) {
    $mask = cidrToMask($cidr);
    if (!$ipIsBin) {
        $ip = inet_pton($ip);
    }
    $ipParts   = str_split($ip, 4);
    $maskParts = str_split($mask, 4);
    $rangeParts  = [];
    for ($i = 0; $i < count($ipParts); $i++) {
        if ($which == 'start') {
            /* Побитовый & адреса и маски оставит только биты префикса. */
            $rangeParts[$i] = $ipParts[$i] & $maskParts[$i];
        } else {
            /* Побитовый | с обратной маской (~) оставит биты префикса и установит все биты локальной части в 1. */
            $rangeParts[$i] = $ipParts[$i] | ~$maskParts[$i];
        }
    }
    $rangeBoundary = implode($rangeParts);
    if ($returnBin) {
        return $rangeBoundary;
    } else {
        return inet_ntop($rangeBoundary);
    }
}

ഭാവിയിലെ ഉപയോഗത്തിനായി, IP ട്രാൻസ്മിറ്റ് ചെയ്യാനും ബൈനറിയിലും മനുഷ്യന് വായിക്കാനാകുന്ന രൂപത്തിലും ഫലം സ്വീകരിക്കാനുമുള്ള കഴിവ് ഞങ്ങൾ നൽകും. പരാമീറ്റർ $ഏത് ശ്രേണിയുടെ തുടക്കമോ അവസാനമോ നമുക്ക് ലഭിക്കണമോ എന്ന് ഇവിടെ വ്യക്തമാക്കുന്നു (മൂല്യങ്ങൾ 'ആരംഭിക്കുക' അഥവാ 'അവസാനിക്കുന്നു' യഥാക്രമം).

അടുത്ത ടാസ്ക് (ഞങ്ങളുടെ കമ്പനിക്ക് ഏറ്റവും പ്രായോഗികവും) അടുത്ത ശ്രേണി കണക്കാക്കുന്നു. ഈ ടാസ്‌ക്കിനായി, വിലാസം ഒരു ബൈനറി സ്‌ട്രിംഗിലേക്ക് വികസിപ്പിച്ച് ആവശ്യമുള്ള സ്ഥാനത്ത് 1 ചേർക്കുകയും തുടർന്ന് എല്ലാം തിരികെ ചുരുക്കുകയും ചെയ്യുന്നതിനേക്കാൾ മികച്ചതായി ഒന്നും മനസ്സിൽ വന്നില്ല. പുരാവസ്തുക്കൾ എവിടെയും പ്രത്യക്ഷപ്പെടാതിരിക്കാൻ, വിഘടിപ്പിക്കുമ്പോഴും അസംബ്ലി ചെയ്യുമ്പോഴും വിലാസം ബൈറ്റ് ഉപയോഗിച്ച് വിഭജിക്കാൻ ഞാൻ തീരുമാനിച്ചു.

function getNextBlock ($ipStart, $cidr, $ipIsBin = false, $returnBin = false) {
    if (!$ipIsBin) {
        $ipStart = inet_pton($ipStart);
    }
    $ipParts = str_split($ipStart, 1);
    $ipBin   = '';
    foreach ($ipParts as $ipPart) {
        $ipBin .= str_pad(base_convert(unpack('H*', $ipPart)[1], 16, 2), 8, '0', STR_PAD_LEFT);
    }
    /* Добавляем 1 в нужном разряде двоичного представления строки "влоб" :) */
    $i = $cidr - 1;
    while ($i >= 0) {
        if ($ipBin[$i] == '0') {
            $ipBin[$i] = '1';
            break;
        } else {
            $ipBin[$i] = '0';
        }
        $i--;
    }
    $ipBinParts = str_split($ipBin, 8);
    foreach ($ipBinParts as $key => $ipBinPart) {
        $ipParts[$key] = pack('H*', str_pad(base_convert($ipBinPart, 2, 16), 2, '0', STR_PAD_LEFT));
    }
    $nextIp = implode($ipParts);
    if ($returnBin) {
        return $nextIp;
    } else {
        return inet_ntop($nextIp);
    }
}

ഔട്ട്‌പുട്ടിൽ, വ്യക്തമാക്കിയിരിക്കുന്ന അടുത്ത വലുപ്പ ശ്രേണിയുടെ പ്രിഫിക്‌സ് നമുക്ക് ലഭിക്കും $cidr. ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ ഞങ്ങളുടെ ക്ലയന്റുകൾക്ക് വിലാസങ്ങളുടെ ബ്ലോക്കുകൾ അനുവദിക്കും.

അവസാനമായി, വിലാസം ശ്രേണിയിൽ പെട്ടതാണോ എന്ന് പരിശോധിക്കുന്നു. ഉദാഹരണത്തിന്, ക്ലയന്റുകൾക്ക് ബ്ലോക്കുകൾ വിതരണം ചെയ്യുന്നതിനായി ഞങ്ങൾ ഒരു ബ്ലോക്ക് /48 അനുവദിച്ചു /64, അസൈൻ ചെയ്യുമ്പോൾ ഞങ്ങൾ അനുവദിച്ച ബ്ലോക്കിനപ്പുറത്തേക്ക് പോകുന്നില്ലെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട് (പ്രായോഗികമായി ഇത് ഉടൻ സംഭവിക്കില്ല, പക്ഷേ ഇപ്പോഴും ഒരു സാധ്യതയുണ്ട്). ഇവിടെ എല്ലാം ലളിതമാണ്. ശ്രേണിയുടെ തുടക്കവും അവസാനവും നമുക്ക് ബൈനറി രൂപത്തിൽ ലഭിക്കുകയും വിലാസം പരിധിക്കുള്ളിലാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു.

function ipInRange ($ip, $rangeStart, $cidr) {
    $start = getRangeBoundary($rangeStart, $cidr, 'start',false, true);
    $end = getRangeBoundary($rangeStart, $cidr, 'end',false, true);
    $ipBin = inet_pton($ip);
    return ($ipBin >= $start && $ipBin <= $end);
}

ഇത് സഹായകരമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. നിങ്ങളുടെ അഭിപ്രായത്തിൽ വിലാസങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള മറ്റ് ഏതെല്ലാം പ്രവർത്തനങ്ങൾ ഉപയോഗപ്രദമാകും? എന്തെങ്കിലും കൂട്ടിച്ചേർക്കലുകളും അഭിപ്രായങ്ങളും കോഡ് അവലോകനങ്ങളും അഭിപ്രായങ്ങളിൽ ഊഷ്മളമായി സ്വാഗതം ചെയ്യുന്നു.

നിങ്ങൾ ഇതിനകം ഞങ്ങളുടെ ക്ലയന്റാണെങ്കിൽ അല്ലെങ്കിൽ ഒരാളാകാൻ ചിന്തിക്കുകയാണെങ്കിൽ, ഈ ലേഖനം പ്രസിദ്ധീകരിക്കുന്ന അവസരത്തിൽ ഒരു ബ്ലോക്ക് ലഭിക്കാൻ ഞങ്ങൾ നിങ്ങൾക്ക് വാഗ്ദാനം ചെയ്യുന്നു /64 ടിക്കറ്റിൽ ഈ ലേഖനത്തിലേക്കുള്ള ലിങ്ക് നൽകിക്കൊണ്ട് സെയിൽസ് ഡിപ്പാർട്ട്‌മെന്റിന്റെ അഭ്യർത്ഥന പ്രകാരം നെതർലാൻഡിലെ Equinix Tier IV ഡാറ്റാ സെന്ററിലെ എല്ലാ vps സേവനങ്ങൾക്കും അല്ലെങ്കിൽ സമർപ്പിത സെർവറുകൾക്കും പൂർണ്ണമായും സൗജന്യമാണ്. ഓഫർ 2020 മാർച്ച് വരെ സാധുവാണ്.

ചില പരസ്യങ്ങൾ 🙂

ഞങ്ങളോടൊപ്പം താമസിച്ചതിന് നന്ദി. ഞങ്ങളുടെ ലേഖനങ്ങൾ നിങ്ങൾക്ക് ഇഷ്ടമാണോ? കൂടുതൽ രസകരമായ ഉള്ളടക്കം കാണാൻ ആഗ്രഹിക്കുന്നുണ്ടോ? ഒരു ഓർഡർ നൽകി അല്ലെങ്കിൽ സുഹൃത്തുക്കൾക്ക് ശുപാർശ ചെയ്തുകൊണ്ട് ഞങ്ങളെ പിന്തുണയ്ക്കുക, $4.99 മുതൽ ഡെവലപ്പർമാർക്കുള്ള ക്ലൗഡ് VPS, എൻട്രി ലെവൽ സെർവറുകളുടെ ഒരു അദ്വിതീയ അനലോഗ്, നിങ്ങൾക്കായി ഞങ്ങൾ കണ്ടുപിടിച്ചതാണ്: VPS (KVM) E5-2697 v3 (6 കോറുകൾ) 10GB DDR4 480GB SSD 1Gbps-നെക്കുറിച്ചുള്ള മുഴുവൻ സത്യവും $19 മുതൽ അല്ലെങ്കിൽ എങ്ങനെ ഒരു സെർവർ പങ്കിടാം? (RAID1, RAID10 എന്നിവയ്‌ക്കൊപ്പം 24 കോറുകൾ വരെയും 40GB DDR4 വരെയും ലഭ്യമാണ്).

ആംസ്റ്റർഡാമിലെ Equinix Tier IV ഡാറ്റാ സെന്ററിൽ Dell R730xd 2 മടങ്ങ് വിലക്കുറവാണോ? ഇവിടെ മാത്രം 2 x Intel TetraDeca-Core Xeon 2x E5-2697v3 2.6GHz 14C 64GB DDR4 4x960GB SSD 1Gbps 100 TV $199 മുതൽ നെതർലാൻഡിൽ! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - $99 മുതൽ! കുറിച്ച് വായിക്കുക ഇൻഫ്രാസ്ട്രക്ചർ കോർപ്പറേഷൻ എങ്ങനെ നിർമ്മിക്കാം. ഒരു പൈസയ്ക്ക് 730 യൂറോ വിലയുള്ള Dell R5xd E2650-4 v9000 സെർവറുകൾ ഉപയോഗിക്കുന്ന ക്ലാസ്?

അവലംബം: www.habr.com