แแฆแแก แฉแแแ แแแแแชแแแแ SQL Server 2019-แแก แแแแแงแแแแแแก แแแฎแแกแแแแแแแแแก Unity XT แจแแแแฎแแแก แกแแกแขแแแแ, แแกแแแ แแแแชแแแ แ แแแแแแแแแชแแแแก SQL Server-แแก แแแ แขแฃแแแแแแชแแแก แจแแกแแฎแแ VMware แขแแฅแแแแแแแแก แแแแแงแแแแแแ, Dell EMC แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แซแแ แแแแแ แแแแแแแแแขแแแแก แแแงแแแแแแกแ แแ แแแ แแแแก แจแแกแแฎแแ.
2017 แฌแแแก Dell EMC-แแ แแ VMware-แแ แแแแแแฅแแแงแแแก แแแแแแแแฎแแแก แจแแแแแแแ SQL Server-แแก แขแแแแแแชแแแแแกแ แแ แแแแแฃแชแแแก แจแแกแแฎแแ - "SQL Server Transformation: Towards Agility and Resilience" (), แ แแแแแแแช แแแแแแงแแแ SQL Server-แแก แแ แแคแแกแแฃแแ แแกแแชแแแชแแแก (PASS) แฌแแแ แแ แกแแแแแแแแแแแก แแแแแชแแแแแแ. แจแแแแแแแ แแฉแแแแแแก, แ แแ SQL Server แแแแแชแแแแ แแแแแก แแแ แแแ แแแ แแแแ แ แแแแ แช แแแแแ, แแกแแแ แกแแ แแฃแแแ, แ แแช แแแแแฌแแแฃแแแ แแแแแชแแแแ แแแชแฃแแแแแก แแแแ แแแ แแ แแฎแแแ แแแแแแก แแแแฎแแแแแแแ. SQL Server แแแแแชแแแแ แแแแแแ แแฎแแ แแแแแแแแแฃแแแ แแแแ แแแแแแแแแจแ, แ แแแแแแแช แแซแแแแ แแแแ แแแกแแแก แแ แแขแแแฃแ แแแแแแแชแแแแก แแ แฎแจแแ แแ แฌแแ แแแแแแแแก แชแแคแ แฃแแ แขแ แแแกแคแแ แแแชแแแก แกแแคแฃแซแแแแก.
แแแก แจแแแแแ, แ แแช แแก แแแแแแ แฉแแขแแ แแ, Microsoft-แแ แแแแแฃแจแแ DBMS-แแก แจแแแแแแ แแแแแ - SQL Server 2019. แแแ แแ แ แแแแชแแฃแ แ แซแ แแแแก แซแแ แแแแแ แคแฃแแฅแชแแแแแก แแแฃแแฏแแแแกแแแแกแ แแ แแแแแชแแแแ แจแแแแฎแแแกแ, แแแแแฉแแแ แแฎแแแ แกแแ แแแกแแแ แแ แคแฃแแฅแชแแแแ. แแแแแแแแแ, SQL Server 2019 แแแแชแแแก แแแแ แแแแแชแแแแแแก แแแขแแแ แแแแก แแฎแแ แแแญแแ แแก Apache Spark-แแกแ แแ Hadoop Distributed File System-แแก (HDFS) แแแแแงแแแแแแ.
Alliance Dell EMC แแ Microsoft
Dell EMC-แกแ แแ Microsoft-แก แแแแ แฎแแแก แแแแแแจแ แแแแแแ แแฅแแ SQL Server-แแก แแแแแฌแงแแแขแแแแแแแแก แจแแแฃแจแแแแแแจแ. แงแแแแแกแแแแชแแแแ แแแแแชแแแแ แแแแแก แแแแขแคแแ แแแก แฌแแ แแแขแแแแ แแแแแ แแแ, แ แแแแ แแชแแ Microsoft SQL Server, แแแแแฎแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แคแฃแแฅแชแแแแแ แแแแก แแแแ แแแแแชแแแก แซแแ แแแแ IT แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ. แแก แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแแแชแแแก แแ แแชแแกแแ แแก แแแแฃแจแแแแแแก แซแแแแก, แแแฎแกแแแ แแแแก แ แแกแฃแ แกแแแก, แจแแแแฎแแแก แแ แฅแกแแแฃแ แกแแ แแแกแแแก. Dell EMC แแแแแแแแแ SQL Server แแแแขแคแแ แแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แงแแแแ แขแแแแก แแแขแแแ แแแแกแ แแ แแแแแแแชแแแกแแแแก.
Dell EMC PowerEdge แกแแ แแแ แแก แฎแแแ แแแแแแแแแ แแ แแชแแกแแ แแกแ แแ แแแฎแกแแแ แแแแก แแ แแแแแคแแ แแแแ แแแแคแแแฃแ แแชแแแก. แแก แแแแคแแแฃแ แแชแแแแ แจแแกแแคแแ แแกแแ แกแแแฃแจแแ แแแขแแแ แแแแก แคแแ แแ แกแแแฅแขแ แแกแแแแก: แแชแแ แ แกแแฌแแ แแแแแแก แแแแแแแชแแแแแแแ แแแฌแงแแแฃแแ แแแกแแแก แงแแแแแแ แแ แแขแแแฃแ แกแแกแขแแแแแแแแ, แ แแแแ แแชแแ แกแแฌแแ แแแก แ แแกแฃแ แกแแแแก แแแแแแแแ (ERP), แแแแแชแแแแ แกแแฌแงแแแแแ, แแแฌแแแแแ แแแแแแขแแแ, แแแแฅแขแ แแแฃแแ แแแแแ แชแแ แแ แ.แจ. แจแแแแฎแแแก แฎแแแ แแแแแฃแแแแแแแ แแ แแกแขแ แฃแฅแขแฃแ แแ แแแฃแแ แแ แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ แแแแแชแแแแแแก แจแแแแฎแแ.
แแแแแแขแแแก, แ แแแแแแแช แแแแแแแแกแแแแ SQL Server 2019-แก Dell EMC แแแคแ แแกแขแ แฃแฅแขแฃแ แแ, แจแแฃแซแแแแ แแแฃแจแแแ แกแขแ แฃแฅแขแฃแ แแ แแแฃแ แแ แแ แแกแขแ แฃแฅแขแฃแ แแ แแแฃแ แแแแแชแแแแแแแ SQL Server-แแกแ แแ Apache Spark-แแก แแแแแงแแแแแแ. SQL Server แแกแแแ แแฎแแ แก แฃแญแแ แก แแแแแแขแแก แฌแแแแแแก, แกแแ แแแ แแแแ แกแแ แแแ แแ แแ แกแแ แแแ แแแแ แจแแกแแแแฎ แกแแแแแฃแแแแแชแแ แขแแฅแแแแแแแแแแก แแแแแแแแชแแแแก. Dell EMC-แแก แฎแแแแ แแแคแฃแซแแแแฃแแแ แแแแแฌแแแ แแแฃแ แแแแแแแ, แ แแแแแแช แแแแแแแแแ แฆแแ แแแแกแแกแขแแแแก. แแ แแแแแแแชแแแแก แจแแฃแซแแแแ แแแ แฉแแแ แแแแฃแกแขแ แแแก แกแขแแแแแ แขแฃแแ แฅแกแแแแก แแแแแแแชแแแแแก, แแแแ แแชแแฃแแ แกแแกแขแแแแแแกแ แแ แแแแ แแขแฃแ แแก แแแแขแคแแ แแแแแก แคแแ แแ แกแแแฅแขแ แแแแ. แแก แแแแแแแ แแแซแแแแ แแแฅแกแแแแแฃแ แแแแขแ แแแก แขแแฅแแแแแแแแแกแ แแ แแ แฅแแขแแฅแขแฃแ แแแแ, แ แแช แแฌแแแแก แฎแแ แฏแแแแก แแแแจแแแแแแแแ แแแแแแแแก แแ แแแฅแแแแแแแก.
VMware แแแ แขแฃแแแแแแแก แงแแแแ แแ แแ แแขแแแฃแ แแแคแ แแกแขแ แฃแฅแขแฃแ แฃแ แแแแแแแแแขแก, แ แแแแแแช แกแญแแ แแแแ SQL Server-แก แแแฆแแแ แจแแกแ แฃแแแแแกแ แแ แแแแ แแชแแฃแแ แแแแแแแแแแ แฃแแแแแก แแแกแแฆแฌแแแแ. แแแ แซแ แฆแ แฃแแแแก แแแ แแ, VMware แแกแแแ แแแแแแแแแ แฐแแแ แแแฃแ แแแแแแแแก แกแแแฃแจแแ แแแขแแแ แแแแกแแแแก, แ แแแแแแแช แแแแชแแแก แแแ แซแ แแ แกแแฏแแ แ แฆแ แฃแแแแแแ แแ แฅแแขแแฅแขแฃแ แแแก.
แแแแ แ แแ แแแแแแแชแแ แแแแแ แแแแก แแแ แขแฃแแแแแแชแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฎแแ แฏแแแแก แจแแกแแแชแแ แแแแแ, แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแก แฃแแ แฃแแแแแกแแงแแคแแ แแ แแแขแแกแขแ แแคแแก แแฆแแแแแแก แแแกแแแแ แขแแแแแแแ. SQL Server-แแก แแแแแแแแฎแฃแแ แแ แแคแแกแแแแแแแแแก 94% แแฆแแแจแแแแก แแแ แขแฃแแแแแแชแแแก แแแ แแแแฃแ แแแแแก แแแ แแแ แแแแจแ. แแแ แขแฃแแแแแแชแแแก แแแแฎแแแ แแแแแแ 70%-แแ แแแ แฉแแ VMware. 60%-แก แแฅแแก SQL Server แแแ แขแฃแแแแแแชแแแก แแแแ 75% แแ แแแขแ. แแแ แแ แแแแกแ, แแแแแแแก แจแแแแแแแ แแขแแแชแแ แแแฃแแแแแแก แแแแแ, แ แแ แแแ แขแฃแแแแแแชแแแก แคแแแแแ แแแแฎแแ แชแแแแแแฃแแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแแ แแ แแแขแแกแขแ แแคแแก แแฆแแแแแ แแแฎแแ แแแแจแแแแแแแแแ แคแแฅแขแแ แ SQL Server แแแแแชแแแแ แแแแแแแก แแแ แขแฃแแแแแแชแแแก แแแแแฌแงแแแขแแแแแแก แแแฆแแแแกแแก.
แแฎแแแ แคแฃแแฅแชแแแแ SQL Server 2019-แจแ
SQL Server 2019 แแแแแชแแแแ แแแแแก แแแแขแคแแ แแ แแแแชแแแก แขแแฅแแแแแแแแแแก, แคแฃแแฅแชแแแแแกแ แแ แกแแ แแแกแแแแก แคแแ แแ แกแแแฅแขแ แก, แ แแแแแแแช แแฎแแ แก แฃแญแแ แแ แแแกแแแก แแ แแขแแแฃแ แแแแแแแชแแแแก, แ แแแแ แแชแแ แแแแแแขแแแ, แกแแฌแแ แแแแ แแแแแชแแแแ แแแแแแ, แแแแแแก แแแขแแแแฅแขแ (BI) แแ แแแกแจแขแแแแ แแแแแ แขแ แแแแแฅแชแแแแแก แแแแฃแจแแแแแ (OLTP). SQL Server-แแก แแแแขแคแแ แแแ แแแแแแแ แแแแแชแแแแ แแแขแแแ แแชแแแก, แแแแแชแแแแ แจแแแแฎแแแก, แแแแแ แแจแแแแแก แแ แแแคแแ แแแแแฃแแ แแแแแแขแแแแก, แ แแแแแแแชแแแก แจแแกแแซแแแแแแแแแแกแ แแ แแแฎแแแ แแ แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ แแแแแชแแแแ แขแแแแแแก แแแ แแแแก แจแแกแแซแแแแแแแแแ. แ แ แแฅแแ แฃแแแ, แงแแแแ แแแแแแขแ แแ แแแแแแแชแแ แแ แแแแแฎแแแก แงแแแแ แแ แคแฃแแฅแชแแแก. แแแ แแ แแแแกแ, แฎแจแแ แจแแแแฎแแแแแจแ แกแแกแฃแ แแแแแ SQL Server แกแแ แแแกแแแแก แแแแแงแแคแ แแแ แขแฃแแแแแแชแแแก แแแแแงแแแแแแ.
แแฆแแก, แแแแแแกแแแก แฎแจแแ แแ แกแญแแ แแแแแ แแแแงแ แแแแ แแแแแชแแแแ แแแ แแแชแฃแแแแแก แแฃแแแแแ แแแแ แแ แแแแแชแแแแ แแแแ แแแแก แคแแ แแ แกแแแฅแขแ แแแแ. SQL Server 2019-แแ, แแฅแแแ แจแแแแซแแแแ แแแแฆแแ แ แแแแฃแ แแ แแจแ แแแคแแ แแแชแแ แแฅแแแแ แงแแแแ แแแแแชแแแแแแ. SQL Server 2019 แแแแกแขแแ แแแ แฃแแ แฃแแแแแงแแคแแ แกแ แฃแแแแกแจแขแแแแแ แแแ แแแแก แแแแแชแแแแ แแแ แแแแ แแแแแแแ แแฃแจแแแแแกแแแแก, แแแ แจแแ แแก แแแแฅแแแฃแ แ แกแฌแแแแแกแ แแ แฎแแแแแแฃแ แ แแแขแแแแฅแขแแก แจแแกแแซแแแแแแแแแแก แแแแแงแแแแแแกแแแแก. แซแแ แแแแแ แแฎแแแ แคแฃแแฅแชแแแแ แแ แแแแแฎแแแแแแ SQL Server 2019-แจแ แฉแแแแแแแแแแ .
Dell EMC Unity XT แกแแจแฃแแแ แแแแแก แจแแแแฎแแแก แกแแกแขแแแ
Dell EMC Unity แกแแชแแแแก แกแแ แแแแ แแแแฅแแแก แกแแแ แฌแแแก แฌแแ แแแแฌแงแ แแ แแแก แจแแแแแ 40-แแ แแแขแ แกแแกแขแแแ แแแแงแแแ. แแแแฎแแแ แแแแแแ แแคแแกแแแแ แแ แกแแจแฃแแแ แแแแแแแแแแก แแแกแแแก แแแกแ แกแแแแ แขแแแแก, แจแแกแ แฃแแแแแกแ แแ แฎแแ แฏแแแแก แแคแแฅแขแฃแ แแแแก แแแแ. Dell EMC Unity XT แกแแจแฃแแแ แแแแแก แแแแขแคแแ แแแแ แแ แแก แกแแแแแ แ แจแแแแฎแแแก แแแแแฌแงแแแขแแแแแแแ, แ แแแแแแแช แฃแแ แฃแแแแแงแแคแแ แแแแแ แจแแงแแแแแแแก, แแแฆแแ แแแแขแแ แฃแแแ แแแแแแแก แแ แแแแแแ แแแ แแแแก แฎแแ แฏแแแก SQL Server-แแก แแแขแแแ แแแแกแแแแก. แงแแแแ Unity XT แกแแกแขแแแ แแงแแแแแก แแ แแแแ แจแแแแฎแแแก แแ แแชแแกแแ แแก (SP) แแ แฅแแขแแฅแขแฃแ แแก I/O แแ แแฅแขแแฃแ แ/แแฅแขแแฃแ แ แแแแแชแแแแ แแแแ แแชแแแแแก แแแกแแแฃแจแแแแแแแ. Unity XT dual SP แแงแแแแแก แกแ แฃแ แจแแแ 000 Gbps SAS แแแแจแแ แก แแ แกแแแฃแแ แแแแก แแ แแแแ แแแ แแแแแ แแ แฅแแขแแฅแขแฃแ แแก แแแฆแแแ แจแแกแ แฃแแแแแกแ แแ แแคแแฅแขแฃแ แแแแกแแแแก. แแแกแแแก แแแกแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแคแแ แแแแแ แจแแแแฎแแแก แแแชแฃแแแแ แแแแแขแแแแแ แแแ แแแแแก แแแแแงแแแแแแ.
Dell EMC Unity XT, แแแกแแแแแแก แจแแแแแแ แแแแแ (แฐแแแ แแแฃแแ แแ แงแแแแ แคแแแจ), แแแแจแแแแแแแแแ แแ แแแก แจแแกแ แฃแแแแแก, แแฃแแฏแแแแกแแแก แแคแแฅแขแฃแ แแแแก แแ แแแแขแแแก แแฎแแ แจแแกแแซแแแแแแแแแกแ แแ แกแแ แแแกแแแก แแ แแแแ แฆแ แฃแแแแแแ แแแ แแแแจแ.
Unity XT แแ แฅแแขแแฅแขแฃแ แ แกแแจแฃแแแแแแก แแแซแแแแ แแ แแแ แแฃแแแ แแแแแฃแจแแแแ แแแแแชแแแแแ, แจแแแแชแแ แแ แแแแแชแแแแ แแแชแฃแแแแ แแ แแฎแแ แ แแแฃแญแแ แแ แกแแ แแแกแแแก, แ แแแแ แแชแแ แ แแแแแแแชแแ, แแแแแแแชแแแก แจแแกแ แฃแแแแแก แจแแฌแแ แแแก แแแ แแจแ. แฌแแแ แแแแแแก แแแแแฌแงแแแขแแกแแแ แจแแแแ แแแแ, Dell EMC Unity XT แจแแแแฎแแแก แกแแกแขแแแแก แแฃแจแแแแ แแแแ แแแแแแฃแแแ แแ แ แแแแแ แแแแก แแ แ 75%-แแ แฃแคแ แ แกแฌแ แแคแแ. แแ แ แ แแฅแแ แฃแแแ, Dell EMC Unity แแฎแแ แก แฃแญแแ แก NVMe แกแขแแแแแ แขแก.
แจแแแแฎแแแก แกแแกแขแแแแแ NVMe แแแกแแแแแ แแฉแแแแแแก แแแ แกแแฃแแแแแกแ แจแแกแ แฃแแแแแก แจแแงแแแแแแแกแแแแ แแแ แซแแแแแแ แ แแแแแแแชแแแแจแ. แแแแแแแแแ, แแแแแแแชแแแแจแ, แ แแแแ แแชแแ แแแกแแฃแ แ แแแแแชแแแแ แแแแแแ, NVMe แฃแแ แฃแแแแแงแแคแก แแแแแแ แจแแงแแแแแแแกแ แแ แแแแแชแแแแ แแแฆแแแ แแแแแก แกแแฉแฅแแ แแก. แจแแแชแแ แแแฃแแ แจแแงแแแแแแ แแ แแแแ แแแแ แแแแแฃแ แแแขแฃแแแแ แแแแจแแแแแแแแแ แแฃแแฏแแแแกแแแก แฌแแแแแฎแแแก/แฉแแฌแแ แแก แแฃแจแแแแแก. แจแแแแฎแแแแแแ แแ แแ แแก, แ แแ IDC-แแก แแ แแแแแแแก แแแฎแแแแแ, 2021 แฌแแแกแแแแก แคแแแจ แแแกแแแแแ NVMe แแ NVMe-oF (NVMe แแแขแ Fabric) แแแแจแแ แแแแ แแฅแแแแ แแกแแคแแแแจแ แแแ แ แจแแแแฎแแแก แกแแกแขแแแแแแก แแแงแแแแแแแ แแแฆแแแฃแแ แจแแแแกแแแแแแแก แแแแฎแแแแแแ แแแฎแแแแ แ.
แแแแแชแแแแ แจแแแฃแแจแแแก แแแแแ แแแแแแ แแฃแแฏแแแแกแแแแ แจแแแแฎแแแก แแคแแฅแขแฃแ แแแแก. Dell EMC Unity XT-แก แจแแฃแซแแแ แแแแแชแแแแ แแแชแฃแแแแแก แจแแแชแแ แแแ แฎแฃแแฏแแ . แแแแแ แแ แแ แแแแจแแแแแแแแแ แแแฉแแแแแแแแแ แกแแกแขแแแแก แกแแแ แแ แแคแแฅแขแฃแ แแแ. Dell EMC Unity XT แแงแแแแแก แกแแกแขแแแแก แกแแแซแแแแ แแก 85%-แก. แจแแแฃแแจแแ แแ แแแแฃแแแแแแชแแ แฎแแ แชแแแแแแแ แแแแแแ แ แแแแแจแ - แแแแขแ แแแแ แแก แแแแแแ. แแแแแชแแแแแ แแแแฎแแแ แจแแแฃแแจแฃแแ แคแแ แแแ. แกแแกแขแแแ แแกแแแ แแแขแแแแขแแแแ แแแก แแฃแจแแแแแก แแแแแชแแแแ แกแแแแจแแขแแแแแ.
แแแแแแแ แแแแแกแแงแแแแแแแ Unity แคแแแจ แแแกแแแแแ แแ แแแแแ (แแแแแแแแแกแ แแ แคแแแแแแแก) แฌแแแแแแ แฃแแ แฃแแแแแงแแคแก แกแขแแแแแฃแ แ แแแแแ แแแแก แแ แแก, แแแขแแแ แแ แแแแ แฆแ แฃแแแแแแแ แจแแแแฎแแแก แกแแ แแแกแแแแแ แแ แแฎแแ แก แฃแญแแ แก แแแแแฎแแแแแก แแแแแชแแแแ แแแแ แแชแแแก แแแ แแจแ. แแแกแ แซแแ แแแแแ แแแแคแแแฃแ แแชแแแ, แแก แแ แแแแแแฎแ แแแ แจแแแแฎแแแก แกแแกแขแแแ แแแกแขแแแแ แแแฃแแแ 30 แฌแฃแแจแ.
แแแแแชแแแแ แจแแแแฎแแแก แขแแฅแแแแแแแ แกแแฎแแแฌแแแแแแ "แแแแแแแฃแ แ แแฃแแแแ" แกแแจแฃแแแแแแก แแแซแแแแ แแแแแฎแแแแแ แกแขแแขแแแฃแ แ แแแฎแกแแแ แแแแก แแแแแแแฃแ แแแคแแ แแแแแแแ, แฃแแ แฃแแแแแงแแคแก แแแฆแแ แแแแ แแชแแฃแ แแแฅแแแแแแแก แแ แกแแกแขแแแแก แกแแแซแแแแ แแก แแแแ แแแก แแแ แขแแแแแแก. แแแแแแแฃแ แ แแฃแแแแ แแแแแแก แกแแแซแแแแ แแก แแ แแแฃแฏแแขแก แแ แกแแญแแ แแแแก แแแแแแ แแ แแก แแฆแแแแแแก. Dell EMC Unity-แแก แจแแกแแซแแแแแแแแแแกแ แแ แแฃแจแแแแแก แแแคแแ แแแแแ แแ แกแแญแแ แแแแก แแแแแชแแแแ แแแแ แแชแแแก.
แแแแ แ แแแแแแแแ แแฆแแก แแงแแแแแก แ แแแแแแแแ แกแแฏแแ แ แฆแ แฃแแแแแแ แกแแ แแแกแก แแแ แจแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ แแ แแแ. Dell EMC Unity XT-แก แจแแฃแซแแแ แคแฃแแฅแชแแแแแ แแแ, แ แแแแ แช Dell Technologies Cloud แแแ แแแแก แแแแแแแแแขแ. แแ แจแแแแฎแแแก แกแแกแขแแแแก แแแแแงแแแแแ แจแแกแแซแแแแแแแ แกแแฏแแ แ แฆแ แฃแแแแจแ แแ แแแแแชแแแแแแก แแแแแขแแแ แจแแกแแซแแแแแแแ แแแ แซแ แฆแ แฃแแแแจแ. แแแ แแ แแแแกแ, แกแแ แแแกแแก แกแแฎแแ แฎแแแแแกแแฌแแแแแแ Dell EMC Unity XT แกแแชแแแ. แแก แแ แแก Dell EMC Cloud Storage Services-แแก แฆแ แฃแแแแแแแ แจแแแแฎแแแก แแ แ-แแ แแ แกแแ แแแกแ.
แฆแ แฃแแแแแแแ แกแแชแแแ แกแฃแ แฃแคแ แ แแแแฃแแแ แฃแแ แฎแแแแ, แ แแแแแ แแแก แจแแฃแซแแแ แแแแฃแแฏแแแแกแแก ROI แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฎแแ แฏแแแแก แจแแแชแแ แแแแ. Cloud Storage Services แแแ แชแแแแแก แแแแฎแแแ แแแแแแ แแแแแชแแแแ แชแแแขแ แแแก แฆแ แฃแแแแแ Dell EMC แกแแชแแแ (แแแ แแแแแ แแแแแแจแแ แแแฃแแ แกแแฏแแ แ แฆแ แฃแแแแแแ แ แแกแฃแ แกแแแแแ) แกแแ แแแกแแก แกแแฎแแ. แแแกแแแ แแฎแแ แแก แแ แแแแแแแ แแแก แจแแฃแซแแแแ แฃแแ แฃแแแแแงแแ แแแฆแแแกแแฉแฅแแ แแแแ (แแแแแแ แจแแงแแแแแแ) แกแแฏแแ แ แฆแ แฃแแแแแแแ แแแแจแแ แ แแแ แแแแแ Dell EMC Unity, PowerMax แแ Isilon แกแแกแขแแแแแแแ แแแแฎแแแ แแแแแก แแแแแชแแแแ แชแแแขแ แจแ.
Unity XT แแฏแแฎแ แแแแชแแแก Unity XT All-Flash, Unity XT Hybrid, UnityVSA แแ Unity Cloud Edition แกแแกแขแแแแแก.
แแ แแแแแ แฐแแแ แแแฃแแ แแ แคแแแจ แแแกแแแแแ
Intel-แแ แแแคแฃแซแแแแฃแแ Unity XT แฐแแแ แแแฃแแ แแ Unity XT All-Flash แจแแแแฎแแแก แกแแกแขแแแแแ แฃแแ แฃแแแแแงแแคแก แแแขแแแ แแ แแแฃแ แแ แฅแแขแแฅแขแฃแ แแก แแแแแแ แฌแแแแแแกแแแแก, แคแแแแแ แฌแแแแแแกแแแแก แแ VMware VVol-แแแแกแแแแก, แฅแกแแแแแ แแแแแแจแแ แแแฃแแ แจแแแแฎแแแก (NAS), iSCSI แแ Fiber Channel (FC) แแ แแขแแแแแแแแก แแฎแแ แแแญแแ แแ. Unity XT Hybrid แแ Unity XT All-Flash แแแแขแคแแ แแแแ NVMe-แกแแแแก แแแแแแ.
Unity XT แฐแแแ แแแฃแแ แกแแกแขแแแแแ แแฎแแ แก แฃแญแแ แก แแ แแแแ แฆแ แฃแแแแแแ แแแ แแแแก. แแ แแแแ แฆแ แฃแแแแ แแแจแแแแก แแแฎแกแแแ แแแแก แแแคแแ แแแแแแก แฆแ แฃแแแแแ แแ แฆแ แฃแแแแจแ แแแแแแแแแแก แ แแกแฃแ แกแแแแก แแแแแงแแแแแแก แแแฅแแแแ แแแ แแแแขแแแแ. แแ แแแแ แฆแ แฃแแแแแแแ แกแแชแแแ แจแแฅแแแแแแ แแแแกแแแแก, แ แแ แฃแแ แฃแแแแแงแแก แแแแแแฃแ แแแ แแ แแแแแชแแแแ แแแ แขแแแแแฃแ แแแ แ แแแแแแแแ แฆแ แฃแแแแแแ แแแแขแคแแ แแแก แจแแ แแก - แแแ แซแ แแ แกแแฏแแ แ. แแก แแแแแแแแก แแฎแแแแก แแ แ แแฎแแแแ แแแแแชแแแแ แแแแแแแแแแแแแก แแ แแชแแกแแแแ, แแ แแแแ แแแแแแแชแแแก แฌแแแแแแก แแ แแแแแแแแแแ แแแแแชแแแแแแ แ แแแแแแแแ แกแแฏแแ แ แฆแ แฃแแแแจแ.
แแก แฐแแแ แแแฃแแ แแแกแแแแแ แแซแแแแ แจแแแแแ แจแแกแแซแแแแแแแแแก:
- แแแกแจแขแแแแ แแแแแ 16 PB แแแแแแฃแแ แกแแแซแแแแ แแแแ.
- แฉแแแแแขแแแแแฃแแ แแแแแชแแแแ แจแแแชแแ แแแแก แจแแกแแซแแแแแแแแแ แงแแแแ แคแแแจ แแฃแแแกแแแแก.
- แกแฌแ แแคแ แแแกแขแแแแชแแ แแ แแแแคแแแฃแ แแชแแ (แกแแจแฃแแแแ 25 แฌแฃแแ แกแญแแ แแแแ).
SSD แขแแฅแแแแแแแ แกแฌแ แแคแแ แแฎแแแฌแแแ แแ แแฎแแแ แ แแแแแฃแชแแฃแ แ แแ แแแฃแฅแขแแแ แแแแแ แแ แแแแแฉแแแแแ แฃแแฎแแแแก แฌแแแแจแ. แแแแแแ แแฃแแแ, แแ แแแแแแแชแแแแ แแแแแ แซแแแแแแ แขแ แแแแชแแฃแแ HDD-แแแแก แจแแชแแแแก SSD-แแแแ แแแฃแแฏแแแแกแแแฃแแ แแฃแจแแแแแก, แแแ แแแแก แกแแแแ แขแแแแกแ แแ แแแแ แแแแก แแแแแแแแก แแแแแแ. Flash-แแก แแแกแแแแแแก แแฎแแแ แแแแแแแ แแแแแแ แฉแแแแแ แฃแคแ แ แแแฌแแแแแ แจแแแแฎแแแก แแแขแแแแขแแแแชแแแกแแแ, แกแแฏแแ แ แฆแ แฃแแแแแแ แแแขแแแ แแชแแแกแแแ แแ แแแแแชแแแแ แแแขแแแ แแ แแแฃแ แแแชแแแกแแแ.
Unity XT All-Flash แกแแกแขแแแแแ แฃแแ แฃแแแแแงแแคแแ แกแแฉแฅแแ แแก, แแคแแฅแขแฃแ แแแแก แแ แแ แแแแ แฆแ แฃแแแแแแ แแฎแแ แแแญแแ แแก. แแแแ แแแฎแแกแแแแแแแแแ:
- แแ แแแแ แแ แแแฃแฅแขแแฃแแแแ.
- แแแแแชแแแแ แจแแแชแแ แแแ 7:1-แแแ.
- แกแฌแ แแคแ แแแกแขแแแแชแแ แแ แแแแคแแแฃแ แแชแแ (แแ แแชแแกแก 30 แฌแฃแแแ แแแแแแ แแ แ แกแญแแ แแแแ).
UnityVSA
UnityVSA แแ แแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแ แแแแกแแแฆแแ แฃแแ แกแแชแแแ VMware ESXi แแแ แขแฃแแแฃแ แ แแแ แแแแกแแแแก, แกแแ แแแ แแก, แกแแแแแ แ แแ แฆแ แฃแแแแแแแ แจแแแแฎแแแก แจแแกแแซแแแแแแแแก แแแแแงแแแแแแ. UnityVSA HA, แแ แแแแ แจแแกแแแแฎแ UnityVSA แแแแคแแแฃแ แแชแแ, แฃแแ แฃแแแแแงแแคแก แแแแแขแแแแ แจแแชแแแแแก แขแแแแ แแแขแแแแก. UnityVSA แจแแแแฎแแแก แแแแแแแแแ:
- 50 แขแ-แแแ แกแ แฃแแ แคแฃแแฅแชแแฃแ แ แแ แแแแแ แจแแแแฎแแแก แแแชแฃแแแแ.
- แแแแกแแแแแแ Unity XT แกแแกแขแแแแแแแ แแ แคแฃแแฅแชแแแแแแ.
- แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแก แกแแกแขแแแแแแก แแฎแแ แแแญแแ แ (UnityVSA HA).
- แแแแจแแ แ, แ แแแแ แช NAS แแ iSCSI.
- แแแแแชแแแแ แ แแแแแแแชแแ แกแฎแแ Unity XT แแแแขแคแแ แแแแแแแ.
Unity Cloud Edition
แคแแแแแแแก แกแแแฅแ แแแแแแชแแแกแ แแ แแแขแแกแขแ แแคแแก แแฆแแแแแแก แแแแ แแชแแแแแกแแแแก แฆแ แฃแแแแแแ, Unity XT แแฏแแฎแ แแแแชแแแก Unity Cloud Edition-แก, แ แแแแแแช แฃแแ แฃแแแแแงแแคแก:
- แกแ แฃแแแ แแแแแ แฉแแฃแแ แจแแแแฎแแแก แจแแกแแซแแแแแแแแแ แฆแ แฃแแแแจแ แแแแแแแแแฃแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแกแแแฆแแ แฃแแ แจแแแแฎแแแก (SDS) แแแแแงแแแแแแ.
- แแแ แขแแแแ แแแแแแแแกแแ แแแแแ แแ แคแแแแแแแก แแแฎแกแแแ แแแ VMware Cloud-แแ AWS-แแ.
- แแแขแแกแขแ แแคแแก แแฆแแแแแแก แแฎแแ แแแญแแ แ, แแแ แจแแ แแก แขแแกแขแแ แแแ แแ แแแแแชแแแแ แแแแแแแ.
Unity XT All Flash SQL Server-แแกแแแแก
Unisphere Research-แแก 2017 แฌแแแก แแแแแ แแจแ, "SQL Server Transformation: Towards Agility and Resilience" () แแแแแแแแฎแฃแแแ 22%-แแ แแฆแแแจแแ, แ แแ แแงแแแแแก แคแแแจ แจแแแแฎแแแก แขแแฅแแแแแแแแก แฌแแ แแแแแแจแ (16%) แแ แแแแ แแแก แแแแก แแแแแแแแแก (6%). 30% แแงแแแแแก แฐแแแ แแแฃแ แแแกแแแแแก, แ แแแแแแแช แจแแแชแแแก แคแแแจ แแแฎแกแแแ แแแแก. 13% แแงแแแแแก แแแ แแแแแ แ แแแแแแ แแแแก แคแแแจ แแแกแแแแแก. 13% SQL Server แแแแแชแแแแ แแแแแก แกแแ แแแแ แแ แแกแแแก แจแแฅแแแ แคแแแจ แกแแชแแแจแ.
แคแแแจ แแแฎแกแแแ แแแแก แแก แกแฌแ แแคแ แแแฆแแแ SQL Server-แแแ แแแแแกแแงแแแแแแแ แแแจแแแแก, แ แแ Unity XT All-Flash แแแกแแแแแ แแแแกแแแฃแแ แแแแ แแแ แแแ แจแแแคแแ แแแ SQL Server-แแก แแแแแแแแแ แแแก แแ แแแแแแแกแขแ แแขแแ แแแก. Unity XT All-Flash แกแแกแขแแแแแ แฃแแ แฃแแแแแงแแคแแ SQL Server-แแก แแแแแแแแแ แแแกแ แแ แแแแแแแกแขแ แแขแแ แแแก แจแแกแแซแแแแแแแแแแแ แแ แแคแแฅแขแฃแ แแแแ, แ แแช แกแชแแแแแแ แแแแก, แ แแกแแช แกแแแแแแแแแ แขแแแแฃแ แ แจแแแแฎแแแก แแ แแแแแก แฅแกแแแแแ (SAN).
Unity XT All-Flash แกแแกแขแแแแแก, แ แแแแแแแช แแแแ แแ แแแ NVMe-แกแแแแก (แแแแแ แฃแคแ แ แแแฆแแแ แจแแกแ แฃแแแแแกแแแแก แแ แแแแแแ แจแแงแแแแแแแกแแแแก), แแฅแแ 2U แคแแ แแแก แคแแฅแขแแ แ, แแฎแแ แก แฃแญแแ แแ แแ แแแ แแแแแ แแ แแชแแกแแ แแแก, แแ แแแแขแ แแแแ แก แแฅแขแแฃแ /แแฅแขแแฃแ แ แแแแแจแ.
Unity XT All-Flash แแแแแแแแ
Unity XT
แแ แแชแแกแแ แแแ
แแแฎแกแแแ แแแ (แแแแ แแ แแชแแกแแ แแ)
แแแฅแก. แแแกแแแแแก แ แแแแแแแแ
แแแฅแก. "แแแแแแฃแแ" แกแแแซแแแแ แ (PB)
380F
1 Intel E5-2603 v4
6c/1.7 GHz
64
500
2.4
480F
2 Intel Xeon แแแ แชแฎแแแกแคแแ แ
4108 8c/1.8 GHz
96
750
4.0
680F
2 Intel Xeon แแแ แชแฎแแแกแคแแ แ
4116 12c/2.1 GHz
192
1,000
8.0
880F
2 Intel Xeon Gold 6130
16c/2.1 GHz
384
1,500
16.0
แแแขแแแแแ แจแแแแซแแแแ แแฎแแแแ แแแกแแแแก แกแแแชแแคแแแแชแแแแจแ ().
แจแแกแแแแฎแ แแฃแแแแ
SQL Server-แแก แแแแ แแ แแ แแคแแกแแแแแแแ แแชแแก, แ แแ แงแแแแ แแแแแแแแ แแแ แกแแชแแแแก แแแกแแแ แฃแแ แฃแแแแแงแแคแก แแแกแแแแแก แแแฏแแฃแคแแแแก แจแแกแแซแแแแแแแแก แฃแคแ แ แแแ แกแแชแแแแก แแ แแแฃแแแแจแ RAID แแแชแแแก แคแแฅแกแแ แแแฃแแ แแแแแ. แแแแแแแแฃแแแฃแ แ แแแกแแแก แฏแแฃแคแแแ RAID แแแชแแแ แแ แแก แขแ แแแแชแแฃแแ แจแแแแฎแแแก แแฃแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ Unity XT แฐแแแ แแแฃแแ แกแแกแขแแแแแ แแฎแแ แก แฃแญแแ แแ แแฎแแแแ แขแ แแแแชแแฃแ แแฃแแแแก, Unity XT All-Flash แแแกแแแแแ แแกแแแ แแแแแแแแแแแ แแแแแแแฃแ แ แจแแแแฎแแแก แแฃแแแแก. แแแแแแแฃแ แ แกแแชแแแแก แแฃแแแแแ, RAID แแแชแแ แแแแแแงแแแแแ แแแกแแแก แคแแ แแแแแแแ - แแแฎแกแแแ แแแแก แแ แแแฃแแแแ แกแ แฃแ แแแกแแแ แแชแแ แแ. แแแแแแแฃแ แ แแฃแแแแ แฃแแ แฃแแแแแงแแคแก แฃแคแ แ แแแข แแแฅแแแแแแแก แแแกแแแก แแฃแแแแแก แแแ แแแแกแ แแ แแแคแแ แแแแแแจแ.
Dell EMC แแแแแแแแแ แกแแฃแแแแแกแ แแ แแฅแขแแแแก แจแแแแฎแแแก แแฃแแแแแก แแแ แแแแกแแแแก, แ แแแ แแแแฆแฌแแแ แแแฅแกแแแแแฃแ แจแแกแ แฃแแแแแก แแแแแแแแฃแ แ แกแแ แแฃแแแ. แแแแแแแแแ, แ แแแแแแแแแแฃแแแ Unity XT แกแแชแแแแก แแฃแแแแแก แ แแแแแแแแแก แจแแแชแแ แแแ แกแแ แแฃแแแก แจแแกแแแชแแ แแแแแ แแ แแแฅแแแแแแแก แแแแ แแแก แแแแแแ. แแฃแแชแ, แแแแแขแแแแแ แกแแชแแแแก แแฃแแแแแก แแแงแแแแแ แจแแแซแแแแ แซแแแแแ แกแแกแแ แแแแแ แแงแแก แแแแแแ แ แจแแแแฎแแแแแจแ, แแแ แจแแ แแก, แ แแชแ แแญแแ แแแแแ:
- แแฎแแ แ แแแฃแญแแ แแ แชแแแแแฃแ แกแแแฃแจแแ แแแขแแแ แแแแแก แกแฎแแแแแกแฎแแ I/O แแ แแคแแแแแแ.
- แ แแกแฃแ แกแแแแก แแแแแงแแคแ แแแ แแแแฃแแ แจแแกแ แฃแแแแแก แแแ แแแแขแ แแแแก แแแกแแฆแฌแแแแ.
- แแแแแงแแแแ แชแแแแ แ แแกแฃแ แกแแแ แแ แแแแแแแแแแแแแแกแแแแก.
- แจแแฅแแแแแ แแแขแแ แ แแแแแแแแ แฌแแ แฃแแแขแแแแแแแกแแแ แแแกแแชแแแแ
แจแแแแฎแแแก แแแชแฃแแแแ (LUNs)
แ แแแแ แแฌแแแแกแฌแแ แแแ แแแแขแ แแแก แแ แแแฅแแแแแแแก แแแกแแแแก แขแแแแแแก แ แแแแแแแแแก แแ แฉแแแแกแแก? SQL Server-แแแ Unity-แจแ แแแฅแกแแแแแฃแ แ แแแฅแแแแแแแกแแแแก แ แแแแแแแแแแฃแแแ แแแแแชแแแแ แแแแแก แแแแแแฃแแ แคแแแแแก แขแแแแแแก แจแแฅแแแ. แแ แแฅแขแแแแจแ, แแ แแแแแแแชแแแแแก แฃแแแขแแกแแแ แแแแแแแแก แแฆแแแก แแขแแแแแ แแแแ, แกแแแแช แแ แแขแแแฃแ แแแแแชแแแแ แแแแแแก แแแแญแแแ แแแฅแกแแแแแฃแ แ แแแฅแแแแแแ แแ แแแแแแแแ แแ แแขแแแฃแแ แแแแแชแแแแ แแแแแก แคแแแแแแ แแแฏแแฃแคแแแฃแแแ แแแแแแ, แฃแคแ แ แแแ แขแแแแ. แฉแแแ แแแ แฉแแแ แแแแแฎแแแแ แงแแแแ แแแแฎแแแแแก แแแแแชแแแแ แแแแแแแแ แแ แแแกแแแ แแแแแแจแแ แแแฃแ แแแแแแแชแแแแแแ แแแแแแจแแ แแแแ, แ แแแแแ แแแแแชแแแแ แแแชแแแกแ แแ แแแแแขแแ แแแแแก แขแแฅแแแแแแแแแ แแงแ แแแแแ แคแแแแแแแก แแแแแแชแแแก แแ แแแแแแแกแแแแก.
แแ แแแแแ แขแแแแก แแแ แแแ แฎแจแแ แแ แ แแฃแแแ, แแแแกแแแฃแแ แแแแ แแแ แขแฃแแแฃแ แแแ แแแแจแ. แแแ แขแฃแแแแแแแฃแแ SQL Server แแแ แแแ แแ แแก แแแ แแ แแแแแแแแ แแแแกแ, แแฃ แ แแแแ แจแแแซแแแแ แฐแฅแแแแแก แ แแแแแแแแ แขแแแแก แคแแแแแก แฐแแกแขแแแแ แแ แ แขแแแแ. แแแแแชแแแแ แแแแแก แแแแแแแกแขแ แแขแแ แแ แแ แแแฎแกแแแ แแแแก แแแแแแแกแขแ แแขแแ แแ (แแ แแ แแแ แแ แแแ) แฃแแแ แแแ แฉแแแก แกแฌแแ แ แแแแแแกแ แแแฅแแแแแแแกแ แแ แจแแแแ แฉแฃแแแแแก แจแแกแแซแแแแแแแแก แจแแ แแก, แ แแแแกแแช แแแแกแแแฆแแ แแแก แจแแกแแฅแแแแแแ แขแแแแแแก แ แแแแแแแแแก.
แคแแแแแก แจแแแแฎแแ
NAS แกแแ แแแ แแแ แแแกแแแแซแแแแก แคแแแแฃแ แกแแกแขแแแแแก Unity XT แกแแชแแแแ. แคแแแแฃแ แกแแกแขแแแแแแ แฌแแแแแ แจแแกแแซแแแแแแแ SMB แแ NFS แแ แแขแแแแแแแแก แแแแแงแแแแแแ, แฎแแแ แแ แแแแแแ แแขแแแแแแแแ แคแแแแฃแ แ แกแแกแขแแแแ แจแแแแซแแแแ แแแแแแงแแแแ แแ แแแ แแ แแขแแแแแ แแ แแแ แแฃแแแ. NAS แกแแ แแแ แแแ แแงแแแแแแ แแแ แขแฃแแแฃแ แแแขแแ แคแแแกแแแก แฐแแกแขแแก SMB, NFS แแ แแ แแแแแแ แแขแแแแแแก แคแแแแฃแ แกแแกแขแแแแแแแ แแแกแแแแแจแแ แแแแแ, แแกแแแ VMware NFS แจแแแแฎแแแกแ แแ VMware แแแ แขแฃแแแฃแ แขแแแแแแแ. แคแแแแฃแ แ แกแแกแขแแแแแ แแ แแแ แขแฃแแแฃแ แ แแแขแแ แคแแแกแแแ แแแแแแ แแแฃแแแ แแ แ NAS แกแแ แแแ แแ, แ แแช แกแแจแฃแแแแแแก แแซแแแแก แ แแแแแแแแ NAS แกแแ แแแ แก แแแแแแงแแแแ แแ แแแแแฏแแ แแแ แฅแแ แแแแแแแกแแแแก. NAS แกแแ แแแ แแแ แแแขแแแแขแฃแ แแ แแจแแแแ, แแฃ แจแแแแฎแแแก แแ แแชแแกแแ แ แแแ แฎแแ แฎแแแแ. แแแแ แแกแแชแแ แแแฃแแ แคแแแแฃแ แ แกแแกแขแแแแแ แแกแแแ แแแ แฎแแ แฎแแแแ.
SQL Server 2012 (11.x) แแ แฃแคแ แ แแแแแแแแแ แแแ แกแแแแ แแฎแแ แก แฃแญแแ แแ Server Message Block (SMB) 3.0, แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แฅแกแแแแก แคแแแแแแแก แแแแแแ แแแแก แจแแกแแแแฎแแ. แ แแแแ แช แแแแแฃแแแแแแแแ, แแกแ แจแแชแแแแแ แแแแกแขแแ แฃแแ แแแกแขแแแแชแแแกแแแแก, แจแแแแซแแแแ แแแแแแกแขแแแแ แแ แกแแกแขแแแแก แแแแแชแแแแ แแแแแแ (แแแกแขแแ แ, แแแแแแ, msdb แแ tempdb) แแ แแแแแชแแแแ แแแแแก แซแ แแแแก แแแแฎแแแ แแแแแก แแแแแชแแแแ แแแแแแ SMB แจแแแแฎแแแก แแคแชแแแ. SMB แแแฎแกแแแ แแแแก แแแแแงแแแแแ แแแ แแ แแแ แแแแขแแ แงแแแแแแแแก แฎแแแแแกแแฌแแแแแแแแก แฏแแฃแคแแแแก แแแแแงแแแแแแกแแก, แ แแแแแ แคแแแแแก แแแแแแ แแแ แแแแแฎแแแก แฌแแแแแแก แแแฆแแ แฎแแแแแกแแฌแแแแ แฅแกแแแฃแ แ แแกแฃแ แกแแ.
SMB แคแแแแแก แแแแแแ แแแแก แจแแฅแแแ SQL Server-แแก แแแแแแแแแแกแแแแก Unity XT แกแแชแแแแ แแ แแก แแแ แขแแแ แกแแแแขแแแแแแ แแ แแชแแกแ: แแฅแแแ แฅแแแแ NAS แกแแ แแแ แก, แคแแแแฃแ แกแแกแขแแแแก แแ SMB แแแแแแ แแแแก. Dell EMC Unisphere Storage Management แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แจแแแชแแแก แแแแคแแแฃแ แแชแแแก แแกแขแแขแก, แ แแแแแแช แแแแแฎแแแ แแแแ แแ แแ แแชแแกแแก แแแกแ แฃแแแแแจแ. แแฃแแชแ, SQL Server-แแก แแแขแแแ แแแแก SMB แคแแแแแแแก แแแแแแ แแแแกแแก แฐแแกแขแแแแแก แแ แแก, แแแกแแแแแแแกแฌแแแแแแแแ แ แแแแแแแแ แแแแจแแแแแแแแแ แแแกแแแ แแแ, แ แแแแแแช แกแฃแแแช แแ แแฎแแแ SMB แคแแแแแก แแแแแแ แแแแก แแแแแงแแแแแแก. Microsoft-แแ แจแแแแแแแ แแแกแขแแแแชแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แกแแแแแฎแแแแก แกแแ แแแแแแแ แชแแแแแ แกแแแแแฎแแแแแ แแ แแแ; แแแขแแแแแแกแแแแก แแฎแแแแ "SQL แกแแ แแแ แแก แแแงแแแแแ SMB แคแแแแแแแก แกแแชแแแแแ แแ แแแ". .
แแแแแชแแแแ Snapshots
แแแแแชแแแแแ แแแฎแแ แแแแแแแแแก แงแแแแแแ แแแแจแแแแแแแแแ แ แแกแฃแ แกแ แแ แแฆแแแแแแแแ แแแกแแแก แแ แแขแแแฃแแ แแแ แแแ แแแแแฎแแแก แฃแคแ แ แแแขแก, แแแแ แ แฃแแ แแแแ แแแแแแขแ. แแฃแชแแแแแแแแ, แ แแ แแแแแแแชแแแแ แงแแแแแแแแก แแงแแก แแแแแแ แ แแแแแจแ, แฃแแ แฃแแแแแงแแคแแแ แแงแแก แฃแฌแงแแแขแ แแแแ แแชแแแแแแ แแ แแแแแฎแแแแแแแ. แแกแแแ แแกแแแ แกแแญแแ แแแแแ แแแฆแแ แจแแกแ แฃแแแแแก แแ แแแแแชแแแแ แฎแแแแแกแแฌแแแแแแแแก แแกแแแ แแแ แแแแขแแแแก แกแแจแฃแแแแแแ, แ แแแแ แแชแแ แแแแแแแแ แแแ แกแแแแจแแขแแก แ แแแแแแแชแแ แแ แแแกแขแแแชแแฃแ แ แ แแแแแแแชแแ.
Unity XT แจแแกแแแแฎแ แแแกแแแ แแแแแแแแแ แแแแแแกแ แแ แคแแแแแก แกแแแแจแแขแแก แจแแกแแซแแแแแแแแแก, แ แแแแแแแช แแแแแ แแแแ แกแแแ แแ แกแแแฃแจแแ แแ แแชแแกแแแก, แแแแ แแชแแแแก แแ แแ แฅแแขแแฅแขแฃแ แแก. Unity-แแก Snapshot แแแแแแแแแแแ แฃแแ แฃแแแแแงแแคแก แแแแแชแแแแ แแแชแแแก แแแ แขแแ แแ แแคแแฅแขแฃแ แแแแก. แกแแแแจแแขแแแ แแแแแแแแแก แแแแแชแแแแ แแฆแแแแแแก - แแแแแ แฃแแแ แแแ แแแแแ แกแแแแจแแขแแ, แแ แจแแแแซแแแแ แแแแแแแแ แแ แแ แฉแแฃแแ แแแแแชแแแแแ แฌแแแ แกแแแแจแแขแแแแ. แจแแแแแแ แชแฎแ แแแ แแแแฉแแแแแแก แแแแ แแแแก แจแแแแฎแแแก แแแ แแแแแแก Unity XT แกแแกแขแแแแแแกแแแแก.
แแแแแชแแแแ แกแแแแจแแขแแแแก แแแแแแฃแ แ แแ แแแกแขแแแชแแฃแ แ แจแแแแฎแแ
แคแแขแแก แขแแแ
CLI
UI
แแแกแแแแแแ
แฎแแแแ
แแแแแแแแแ
แฎแแแแ
แแแแแแแแแ
แฎแแแแ
แแแแแแแแแ
แแแแแแแแ แแแ
1 แฌแแแ
1 แฌแแแ
5 แฌแแแก
4 แแแแ แแจแ
100 แฌแแแก
แแแ แแจแ แจแแแฆแฃแแแแแ
แแแกแขแแแชแแฃแ แ
5 แฌแแแก
255 แแแแ แแก
5 แฌแแแก
255 แแแแ แแก
5 แฌแแแก
255 แแแแ แแก
Snapshots แแ แแ แแก แแแ แแแแแ แ แฉแแแแชแแแแแ แแแแแชแแแแ แแแชแแแก แกแฎแแ แแแแแแแแแกแแแแก, แ แแแแ แแชแแ แกแแ แแแแ แแ แแกแแแแ. แแแ แจแแฃแซแแแแ แแฎแแแแ แจแแแแกแแ แขแ แแแแชแแฃแแ แกแแ แแแแ แแ แกแแจแฃแแแแแ, แ แแแแ แช แแแแแแชแแแก แแแ แแแแ แฎแแแ แแแแแแ RTO แกแชแแแแ แแแแกแแแแก.
Dell EMC Unity แกแแแแจแแขแแก แคแฃแแฅแชแแ แแแแชแแแก แแแแแชแแแแ แจแแแชแแ แแแแก แแ แแแคแแ แแแแแฃแ แแแแฃแแแแแแชแแแก. Snapshots แแกแแแ แกแแ แแแแแแแก แกแแแ แชแแก แแแแแแแแ, แ แแแแแแช แแแแฆแฌแแแ แแ แแแแแแแฃแ แ แจแแแแฎแแแก แ แแกแฃแ แกแแ. แ แแแแกแแช แแฆแแแ แจแแแแฎแแแก แ แแกแฃแ แกแแก แกแฃแ แแแก, แ แแแแแแช แแฎแแ แก แฃแญแแ แก แแแแแชแแแแ แจแแแชแแ แแแแก แคแฃแแฅแชแแแแก, แฌแงแแ แแจแ แแ แกแแแฃแแ แแแแแชแแแแแ แจแแแซแแแแ แจแแแฃแแจแฃแแ แแ แแฃแแแแแแขแ แแงแแก.
แแฅ แแแชแแแฃแแแ แ แแแแแแแแ แจแแแแจแแแ แแแแแชแแแแ แแแแแก แแฆแแแแแแกแแแ แแแแแแจแแ แแแแ SQL Server แแแแแชแแแแ แแแแแแแ แกแแแแจแแขแแแแก แแแแแงแแแแแแกแแก:
- SQL Server แแแแแชแแแแ แแแแแก แงแแแแ แแแแแแแแแขแ แแแชแฃแแ แฃแแแ แแงแแก แแแแแชแแแแ แแแแ แแแแก แกแแฎแแ. แ แแแแกแแช แแแแแชแแแแแ แแ แแฃแ แแแแแก แคแแแแแแ แกแฎแแแแแกแฎแแ LUN-แแแ, แแก LUN แฃแแแ แแงแแก แแแแแแแแแแ แฃแแ แฏแแฃแคแแก แแแฌแแแ. แแแแแแแแแแ แฃแแ แฏแแฃแคแ แฃแแ แฃแแแแแงแแคแก แกแแแแจแแขแแก แแ แแแ แแฃแแแ แแแแแฆแแแแก แฏแแฃแคแแก แงแแแแ LUN-แแ. แ แแแแกแแช แแแแแชแแแแแ แแ แแฃแ แแแแแก แคแแแแแแ แ แแแแแแแแ SMB แคแแแแแก แแแแแแ แแแแแแ, แแแแแแ แแแแแ แฃแแแ แแงแแก แแแแแ แคแแแแฃแ แกแแกแขแแแแแ.
- SQL Server-แแก แแแแแชแแแแ แแแแแก แแฆแแแแแแกแแก แแแแแแ แแแคแฃแซแแแแฃแแ แกแแแแจแแขแแแแ, แแฃ SQL Server แแแกแขแแแชแแ แฃแแแ แแแ แฉแแก แแแแแแจแแ แแแฃแแ, แแแแแแงแแแแ Unisphere แฐแแกแขแแก แจแแแ แแแแ. แคแแแแแ แแแคแฃแซแแแแฃแแ แแฆแแแแแแกแแแแก, แแแแแขแแแแแ SMB แแแแแแ แแแ แแฅแแแแแ แกแแแแจแแขแแก, แ แแแแ แช แฌแงแแ แแก แแแแแงแแแแแแ. แขแแแแแแก แแแแแแขแแแแแแก แจแแแแแ, แแแแแชแแแแ แแแแ แจแแแซแแแแ แแแแ แแแก แกแฎแแ แกแแฎแแแแ แแ แแ แกแแแฃแแ แแแแแชแแแแ แแแแ แจแแแซแแแแ แจแแแชแแแแแก แแฆแแแแแแแแ.
- Unisphere-แจแ Snapshot Restore แแแแแแแก แแแแแงแแแแแแ แแฆแแแแแแก แจแแกแ แฃแแแแแกแแก, แแแแแแฆแแ SQL Server-แแก แแแแแแแแ แฎแแแแแ แแจแ. SQL แกแแ แแแ แแ แแ แแชแแก แแฆแแแแแแก แแแแ แแชแแแแแก แจแแกแแฎแแ. แฎแแแแแ แแจแ แแแแแแแแแก แแแฆแแแ แฃแแ แฃแแแแแงแแคแก, แ แแ แขแแแแแ แแ แแแแแแแแแก แแแแแชแแแแ แแแแแก แฉแแฌแแ แแ แแฆแแแแแแแแ. แแแกแขแแแชแแแก แแแแแขแแแ แแแแก แจแแแแแ, SQL Server แแแขแแกแขแ แแคแแก แแฆแแแแแ แแแแขแแแก แแแแแชแแแแ แแแแแแก แแแแแแแแแแ แฃแ แแแแแแแ แแแแแจแ.
- แฉแแ แแแ แกแแแแจแแขแแแ แแ แแแ แแฃแแแ แแ แแแแแ แจแแแแฎแแแก แแแแแฅแขแแกแแแแก แแ แจแแแแแ แแแ แฌแแฃแแแแ, แ แแ แกแแกแขแแแ แแ แแก แ แแแแแแแแแแฃแ แแแแ แแชแแฃแ แ แแแแแแแจแ, แกแแแแ แฉแแ แแแ แแแแแขแแแแแ แกแแแแจแแขแแแ.
แกแ แแแแแแก แแแขแแแแขแแแแชแแ แแ แแแแแแแแ
Snapshots Unity XT-แจแ แจแแแซแแแแ แแแขแแแแขแแแแ แแแฃแแ แแงแแก. แจแแแแแแ แแแแฃแแแกแฎแแแแ แกแแแแจแแขแแก แแแ แแแแขแแแ แฎแแแแแกแแฌแแแแแแ Unisphere แจแแแแฎแแแก แแแแแฏแแแแขแจแ: แแแแฃแแแกแฎแแแแ แแแชแแ, แฎแแแแแแแ แจแแแแแแแแก แแแชแแ แแ แฃแคแ แ แแ แซแแแ แจแแแแแแแแก แแแชแแ. แแแแแแฃแแ แแแ แแแแขแ แแฆแแแก แงแแแแแแฆแแฃแ แแแแ แแแก แแ แแแแฎแแแก แแแ แแ แแแก แกแฎแแแแแกแฎแแ แแแ แแแแจแ.
แแฅแแแ แจแแแแซแแแแ แแแ แฉแแแ แแ แแ (แแ แแ แแแ) แแแแแแแแแก แแแ แแแแขแแแแแแ - แงแแแแ x แกแแแแจแ (1-แแแ 24-แแแ) แแ แงแแแแแแฆแแฃแ แแ/แแแแ แแจแ. แงแแแแแแฆแแฃแ แ/แงแแแแแแแแ แแฃแแ แแแแ แแแแก แแแแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแแแแแ แแแแแ แแขแฃแแ แแ แ แแ แแฆแ แกแแแแจแแขแแแแก แแแแแกแแฆแแแแ. แแแแแแฃแแ แแ แฉแแฃแแ แแแ แแแแขแแกแแแแก, แแฅแแแ แฃแแแ แแแแงแแแแ แจแแแแฎแแแก แแแแแขแแแ, แ แแแแแก แแแแคแแแฃแ แแชแแ แจแแกแแซแแแแแแแ แแฃแแแก แแแขแแแแขแฃแ แแ แฌแแจแแแก แแ แแ แแแแแ แจแแกแแแแฎแแ.
แแแแแขแแแแแ แแแคแแ แแแชแแ Unity snapshots-แแก แจแแกแแฎแแ - แแแกแแแแ แแแ .
แแฎแแแ แแแแแแแ
แแฎแแแ แแแแแ แแ แแก แแฎแแแ แแแแแแก แจแแแแฎแแแก แ แแกแฃแ แกแแก แฌแแแแแฎแแแก/แฉแแฌแแ แแก แแกแแ, แ แแแแ แแชแแ แแแชแฃแแแแ, แแแแแแแแแแ แฃแแ แฏแแฃแคแ แแ VMware VMFS แแแแแชแแแแ แกแแชแแแ, แ แแแแแแช แแแแแ แแแก แแแแแแแก แแแแแก แแแแแแ แ แแกแฃแ แกแแแ. แแฎแแแ แแแแแแแ แจแแกแแแแจแแแแ แกแแจแฃแแแแแแ แกแฌแ แแคแแ แแ แแแแแแฅแขแฃแ แแ แฌแแ แแแแแแแแแ SQL Server แแแแแชแแแแ แแแแแก แแกแแแแ, แ แแกแแช แขแ แแแแชแแฃแแ SQL Server แแแกแขแ แฃแแแแขแแแ แแแ แแแแฆแฌแแแแ. แแแก แจแแแแแ, แ แแช แแฎแแแ แแแแแ แฌแแ แฃแแแแแก แแแกแแแแซแแแก, แขแแแแแ แจแแแซแแแแ แจแแแแแขแแแแ แแแแแแ แแ แแแแแชแแแแ แแแแ แแแแ แแแแแ DB Attach แแแแแแแก แแแแแงแแแแแแ SQL Server-แจแ.
แแฎแแแ แแแแแแแแ แแแแแฎแแแแแก แคแฃแแฅแชแแแก แแแแแงแแแแแแกแแก, แแแแแแฆแแ แงแแแแ แแแแแชแแแแ แแแแ แแฎแแแ แแแแแแ แฎแแแแแ แแจแ. แแก แฃแแแ แแแแแแแแก แแแแแฎแแแแแก แแแแ แแชแแแแแ. แแแแแฎแแแแแก แแแแฎแแ แชแแแแแแแแแ แแแแแชแแแแ แแแแแแแก แฎแแแแแ แแจแ แแแแแงแแแแแ แจแแแซแแแแ แแแแแแฌแแแแก แแแแแชแแแแ แจแแฃแกแแแแแแแแก แจแแชแแแแแแ แแ แแแแแชแแแแ แแ แแกแฌแแ แ แจแแแแแแแ SQL Server-แแ.
แแแแแชแแแแ แ แแแแแแแชแแ
แ แแแแแแแชแแ แแ แแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แคแฃแแฅแชแแ, แ แแแแแแช แกแแแฅแ แแแแแแแก แแแแแชแแแแแก แแแกแขแแแชแแฃแ แกแแกแขแแแแกแแแ แแแแแ แกแแแขแแ แแ แกแฎแแ แแแแแแแก. Unity-แแก แ แแแแแแแชแแแกแ แแ แแแแคแแแฃแ แแชแแแก แแแ แแแแขแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแ แฉแแแ แแคแแฅแขแฃแ แ แแแ SQL Server-แแก แแแแแชแแแแ แแแแแแแกแแแแก RTO/RPO แแแแฎแแแแแแแก แแแกแแแแแงแแคแแแแแแแ, แแฃแจแแแแแกแ แแ แแแแขแแ แฃแแแ แแแแแแแก แแแแแแแแกแแแแกแแก.
แ แแแแกแแช แแงแแแแแ Dell EMC Unity Replication-แก SQL Server แแแแแชแแแแ แแแแแแแก แแแกแแชแแแแ แแ แแแแ แขแแแแ, แแฅแแแ แฃแแแ แจแแแแแคแแ แแแแ แแแแแชแแแแ แแแแแจแ แแ แกแแแฃแแ แงแแแแ แแแแแชแแแแกแ แแ แแฃแ แแแแแก แขแแแ แแ แแ แแแแแแแแแแ แฃแแ แฏแแฃแคแแ แแ แคแแแแฃแ แ แกแแกแขแแแแ. แ แแแแแแแชแแ แแแงแแแแแฃแแแ แฏแแฃแคแแ แแ แคแแแแฃแ แกแแกแขแแแแแ แแ แจแแแซแแแแ แจแแแชแแแแแก แแ แแแแ แแแแแชแแแแ แแแแแก แขแแแแแก แแ แแฅแชแแแแก. แแแแแชแแแแ แแแแแแ, แ แแแแแแแช แกแแญแแ แแแแแ แ แแแแแแแชแแแก แกแฎแแแแแกแฎแแ แแแ แแแแขแก, แฃแแแ แแงแแก แชแแแแแฃแ LUN-แแแแ, แแแแแแแแแแ แฃแ แฏแแฃแคแแแแ แแ แคแแแแฃแ แกแแกแขแแแแแแ.
แแฎแแแ แแแแแแแ แแแแกแแแแแแ แ แแแแ แช แกแแแฅแ แแแฃแ, แแกแแแ แแกแแแฅแ แแแฃแ แ แแแแแแแชแแแกแแแ. แ แแแแกแแช แแฎแแแ แแแแแ แแ แแแแแแแ แแแแแจแแฃแแแแแก แแแแแแแ, แแก แฎแแแแ แแแชแฃแแแแแก, แแแแกแแกแขแแแชแแแก แฏแแฃแคแแก แแ VMFS แจแแแแฎแแแก แกแ แฃแแ แแกแแ. แ แแแแแแแชแแแก แจแแแแแ, แแฎแแแ แแแแแ แแ แแก แกแ แฃแแแแ แแแแแฃแแแแแแแแ แขแแแ แกแแแฃแแแ แ แแแ แแแแขแ แแแแ.
แฌแแ แแแ แแแแแแก แ แแแแแแแชแแแก แแ แแชแแกแ แฌแงแแ แแกแ แแ แกแแแแแแ แกแแกแขแแแแแก แจแแ แแก.
tempdb แแแแแชแแแแ แแแแแก แ แแแแแแแชแแ แแ แแ แแก แกแแญแแ แ, แ แแแแแ แคแแแแ แฎแแแแฎแแ แแจแแแแแแ SQL Server-แแก แแแแแขแแแ แแแแกแแก แแ, แจแแกแแแแแแกแแ, แแแขแแแแแแชแแแแแ แแ แจแแแกแแแแแแแ แกแฎแแ SQL Server แแแกแขแแแชแแแแแก แแแแแแก. แแแกแแแ แแแแแแแแ แขแแแแแแก แคแ แแฎแแแแ แจแแ แฉแแแ แแ แแ แขแแแแแแก แจแแแแแ แกแ แแแแแ แแชแฎแแแก แแ แแกแแญแแ แ แ แแแแแแแชแแแก แขแ แแคแแแก.
แแแขแแแ แแ แแแฃแแ Microsoft SQL Server แแแแแชแแแแ แแกแแแก แแแแแฏแแแแขแ
แแแแแแแแ แแแ แจแแแแฎแแแก แแ แแแฃแฅแขแแแก (แแแ แจแแ แแก Dell EMC-แแก แงแแแแ แแ แแแฃแฅแขแก) แจแแฃแซแแแแ แจแแฅแแแแ แแแแแกแแแแ แ แขแแแแก แคแแแแแก "แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแแแแแแแ แฃแแ" แแกแแแแ:
- แแแแแแแแแแ แฃแแ แฉแแฌแแ แแก แแ แซแแแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแ แงแแแแ แแแแแแ - แฐแแกแขแแแแ แแแกแแแแแ.
- แขแแแแแแก แแแฏแแฃแคแแแ แแกแ, แ แแ แกแฎแแแแแกแฎแแ แขแแแแ แแ แแแแแแ แคแแแแแ แจแแแแแ แฉแฃแแแก แฌแแ แแก แแแแแแแแแแ แแแ.
แแแกแจแขแแแฃแ แ แจแแแแฎแแแก แแแฌแงแแแแแแแแแแก แคแแ แแแ แแแแ แชแแแแแแ, Microsoft-แแ แจแแแแฃแจแแแ API แจแแแแฎแแแก แแ แแแแแแแ แแแแกแแแแก. แแก API แกแแจแฃแแแแแแก แแซแแแแก แแแฎแกแแแ แแแแก แแ แแแแแแแ แแแก แแแแ แแแแแชแแ แแแฃแฌแแแ SQL Server แแแแแชแแแแ แแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก, แ แแแ แจแแฅแแแแ "แแแแแแแชแแแก แแแแแแแแแแ แฃแแ แแกแแแแ" Volume Shadow Copy Service (VSS) แแแแแงแแแแแแ. แแก แแกแแแแ แแฎแแแแแ SQL Server-แกแ แแ แแแแ แแชแแฃแ แกแแกแขแแแแก แจแแ แแก แฃแ แแแแ แแฅแแแแแแแก แกแแแฃแแแชแแแก SQL Server-แแก แแแแแแแแแ แแ แแแแแ แแแแก แแ แแก. แฉแแฌแแ แแก แงแแแแ แแฃแคแแ แ แแจแแแแ แแ แขแ แแแแแฅแชแแแแ แจแแฉแแ แแแฃแแแ แแแแแ, แกแแแแ แงแแแแ แแแกแแ แแแแแฎแแแแแ แแ แแแแแแแแแแ แฃแแแ แแ แแแก แแแ แแแแฃแ แแแแแแขแจแ, แ แแช แฉแแแฌแแ แแแ SQL แแฃแ แแแแจแ.
Dell EMC AppSync แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ, แ แแแแแแช แแแขแแแ แแ แแแฃแแแ Unity XT แกแแแแจแแขแแแแแ, แแแแ แขแแแแแก แแ แแแขแแแแขแแแแ แแแก แกแแแฃแจแแ แแแแแชแแแแแแก แแแแแแแชแแแก แจแแกแแแแแแกแ แแกแแแแแก แจแแฅแแแแก, แแแแแงแแแแแแกแ แแ แแแ แแแแก แแ แแชแแกแก. แแก แแ แแแ แแแ แแแแแฃแแแแแแแ แแกแแแก แแแแขแ แแแแก แกแชแแแแ แแแจแ แแแแแกแแงแแแแแแแ แแแแแชแแแแ แแแแแก แแฆแแแแแแกแ แแ แฎแแแแฎแแแ แแแแแงแแแแแแกแแแแก.
AppSync แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แแแขแแแแขแฃแ แแ แแฆแแแแฉแแแก แแแแแแแชแแแก แแแแแชแแแแ แแแแแแก, แกแฌแแแแแแก แแแแแชแแแแ แแแแแก แกแขแ แฃแฅแขแฃแ แแก แแ แแกแแฎแแแก แคแแแแแก แกแขแ แฃแฅแขแฃแ แแก แแแแ แแขแฃแ แแก แแ แแแ แขแฃแแแแแแชแแแก แคแแแแแแก แแแจแแแแแแ Unity XT แกแแชแแแจแ. แแก แแฌแแกแ แแแแแก แงแแแแ แกแแญแแ แ แแแแแฏแก, แแแฌแงแแแฃแแ แแกแแแก แจแแฅแแแแแแ แแ แแแแแแแฌแแแแแแแ, แกแแแแแแ แฐแแกแขแแ แกแแแแจแแขแแแแก แแแแแแขแแแแแแแแ แแ แแแแแชแแแแ แแแแแก แแแฌแงแแแแแแ แแ แแฆแแแแแแแแ. AppSync แแฎแแ แก แฃแญแแ แก แแ แแแแ แขแแแแแก SQL Server-แแก แกแแแฃแจแแ แแ แแชแแกแแแก, แ แแแแแแแช แแแแชแแแก แฌแแ แแแแแแก แแแแแชแแแแ แแแแแก แแแแแฎแแแแแก แแ แแฆแแแแแแก.
แแแแแชแแแแ แจแแแชแแ แแแ แแ แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแ
Dell EMC Unity แจแแแแฎแแแก แกแแกแขแแแแแแก แแฏแแฎแ แแแแแแแแแ แคแฃแแฅแชแแแแแ แแแแแแ , แแแแแแแ แแแแแกแแงแแแแแแ แกแแ แแแกแแแก แแแแแชแแแแ แจแแแชแแ แแแแกแแแแก. แแแแแแแแ แแแแฆแฌแแแ แแ แ แแฎแแแแ แแแแคแแแฃแ แแ แแแฃแ แแแ แแแแแแ แจแแแแฎแแแก แ แแกแฃแ แกแแแแ, แแ แแแแ แแ แ แแกแฃแ แกแแแแก แกแแแแจแแขแแแกแ แแ แฌแแ แแ แแแแแแแแ. Snapshots แแ แแฎแแแ แแแแแแแ แแแแแแแแ แแแแแ แแฆแแแแ แแแแแชแแแแ แจแแแชแแ แแแแก แแแ แแแแขแ แก แฌแงแแ แแก แจแแแแฎแแแกแแก, แ แแช แแ แแแก แกแแแซแแแแ แแก แแแแแแแแก.
แแแแแชแแแแ แจแแแชแแ แแแแก แคแฃแแฅแชแแ แแแแชแแแก แแฃแแแแ แแแแก, แจแแแฃแแจแแแก แแ แแฃแแแแแแ แแแแแแก แแแแแแแแแแก แแฅแขแแแแแแแก, แ แแช แแแขแแแชแแฃแ แแ แแแแ แแแก แแแแฎแแแ แแแแแก แแแแแฅแขแแแแกแ แแ แจแแแ แแแแแงแแแแแแกแแแแก แแแแแกแแงแแแแแแแ แจแแแแฎแแแก แกแแแ แชแแก แ แแแแแแแแแก. Unity XT แแแแแชแแแแ แจแแแชแแ แแแแก แคแฃแแฅแชแแ แชแแแแก แจแแแฃแแจแแแก แคแฃแแฅแชแแแก Unity OE 4.3-แจแ แแ แจแแแแแแจแ. แจแแแฃแแจแแ แแ แแก แแแแแชแแแแ แจแแแชแแ แแแแก แแแแแ แแแแ, แ แแแแแกแแช แจแแฃแซแแแ แจแแแแชแแ แแก แกแแแซแแแแ แแก แคแแแแแฃแ แ แแแแแฌแแแแแ, แ แแแแแแช แกแแญแแ แแ แแแแแชแแแแ แแแแ แแแแก แจแแกแแแแฎแแ.
Unity XT แกแแกแขแแแแแ แแกแแแ แฃแแ แฃแแแแแงแแคแแ แแแฌแแแแแ แแแแฃแแแแแแชแแแก แคแฃแแฅแชแแแก, แ แแแแแแช แจแแแซแแแแ แฉแแ แแแ, แแฃ แฉแแ แแฃแแแ แแแแแชแแแแ แจแแแชแแ แแแ. แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแ แแแชแแ แแแก แแแแฎแแแ แแแแแก แแแแแชแแแแแแกแแแแก แกแแญแแ แ แแแชแฃแแแแแก Unity แแแแแชแแแแ แแแแแแแแก แแฎแแแแ แแชแแ แ แ แแแแแแแแแก แแกแแแแแก (แฎแจแแ แแ แแฎแแแแ แแ แแ แแกแแแก) แจแแแแฎแแแ. แแแแฃแแแแแแชแแแก แแ แ แแ แแก แแ แแ LUN. แแแแแแแแแกแฌแแแแ แแก แจแแแแฎแแแก แกแฅแแแแก แแ แฉแแแแกแแก. แแแแแแแ LUN แแฌแแแแก แฃแแแแแก แแแแฃแแแแแแชแแแก, แแแแ แแ แแแขแ LUN แฃแแ แฃแแแแแงแแคแก แฃแแแแแก แจแแกแ แฃแแแแแก.
แกแแแซแแแแ แแก แแแแแแแ แแแฌแแแแแ แแแแฃแแแแแแชแแแก แจแแแแแแ แจแแแซแแแแ แฃแแ แฃแแแแแงแแก แฃแแแแแกแ แกแแ แแแแแแ แฃแแแขแแก แแแ แแแแจแ, แแแแ แแ แแกแแแ แแแแแฎแแแก Unity แแแกแแแแก แแ แแชแแกแแ แแแแก แแแแแงแแแแแแก. OE 5.0-แจแ, แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแ, แ แแแแกแแช แฉแแ แแฃแแแ, แแจแแ แแแก แแแแแกแแแแ แแแแแก (แจแแแฃแแจแฃแแ แแ แจแแฃแแฃแแจแฃแแ). แแแแแขแแแแแ แแแคแแ แแแชแแแกแแแแก แแฎ .
แจแแแแแแ แชแฎแ แแแ แแแแฉแแแแแแก แแฎแแ แแแญแแ แแ แแแแคแแแฃแ แแชแแแแก แแแแแชแแแแ แจแแแชแแ แแแแกแ แแ แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแแกแแแแก:
แแแแแชแแแแ แจแแแชแแ แแแ Unity-แจแ (แงแแแแ แแแแแแ) แแ แแแซแแแแ แแแฃแแ แแแแฃแแแแแแชแแแก แแฎแแ แแแญแแ แ
Unity OE แแแ แกแแ
ะขะตั ะฝะพะปะพะณะธั
แแฎแแ แแแญแแ แแแ แแฃแแแก แขแแแ
แแฎแแ แแแญแแ แแแ แแแแแแแแ
4.3 / 4.4
แแแแแชแแแแ แจแแแชแแ แแแ
แคแแแจ แแแฎแกแแแ แแแแก แแฃแแ - แขแ แแแแชแแฃแแ แแ แแแแแแแฃแ แ
300, 400, 500, 600, 300F, 400F, 500F, 600F, 350F, 450F, 550F, 650F
4.5
แแแแแชแแแแ แจแแแชแแ แแแ
300, 400, 500, 600, 300F, 400F, 500F, 600F, 350F, 450F, 550F, 650F
แแแแแชแแแแ แจแแแชแแ แแแ แแ แแแคแแ แแแแแฃแแ แแฃแแแแ แแแ *
450F, 550F, 650F
5
แแแแแชแแแแ แจแแแชแแ แแแ
300, 400, 500, 600, 300F, 400F, 500F, 600F, 350F, 450F, 550F, 650F, 380, 480, 680, 880, 380F, 480F,
แแแแแชแแแแ แจแแแชแแ แแแ แแ แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแ
450F, 550F, 650F, 380, 480, 680, 880, 380F, 480F, 680F, 880F
* แแแแแชแแแแ แจแแแชแแ แแแ แแแแฃแแแกแฎแแแแแ แแแแแ แแฃแแแ แแ แฃแแแ แแงแแก แฉแแ แแฃแแ, แกแแแแ แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแ แฎแแแแแกแแฌแแแแแ แแแ แแแแขแ แแแฎแแแแ. แแแแแชแแแแ แจแแแชแแ แแแแก แฉแแ แแแแก แจแแแแแ, แแแคแแ แแแแแฃแแ แแแแฃแแแแแแชแแ แฎแแแแแกแแฌแแแแแแ, แแแแ แแ แแแแฃแแแกแฎแแแแแ แแแแแ แแฃแแแ.
แแแแแชแแแแ แจแแแชแแ แแแ Unity-แจแ แแ แแแแแชแแแแ แจแแแฃแแจแแ SQL Server-แจแ
SQL Server 2008 Enterprise Edition แแงแ แแแ แแแแ แแแแแชแแแ, แ แแแแแแช แจแแกแแแแแแ แแแแแชแแแแ แจแแแฃแแจแแแก แจแแกแแซแแแแแแแแแก. SQL Server 2008 แแฌแแ แแแแก แแ แแแแ แแแก แแแแแก แจแแแฃแแจแแ แแงแแแแแก SQL Server แแแแแชแแแแ แแแแแก แชแฎแ แแแแก แจแแแ แคแแ แแแขแแก แชแแแแแก แแแแแชแแแแ แแแแแก แแแแแฅแขแแแแก แแแแ แแแฎแแแ แแแฃแแ แกแแแ แชแแก แจแแกแแแชแแ แแแแแ. แกแแแ แชแแก แจแแแชแแ แแแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแแแแฎแแ แแแขแ แแฌแแ แแแ แแแแ แแแแ แแแ แแ แแแขแ แแแแ แแ แแฃแคแแ แฃแ แแฃแแจแ. แแแแก แแแแ, แ แแ แแแแแชแแแแแ, แ แแแแแแแช แแ แแ แแก แจแแแแฎแฃแแ 8k แแแแแชแแแแ แแแแ แแแก แคแแ แแแขแจแ, แ แแแแ แแชแแ แกแขแ แแฅแแแแก แแแ แแ แแ แกแแแฃแแ แแแแแชแแแแแ, แ แแแแ แแชแแ NVARCHAR(MAX), แแ แแแแแแงแแแแแก แแฌแแ แแแแก แแ แแแแ แแแก แจแแแฃแแจแแแก แแแแแแแแก, Microsoft-แแ แจแแแแแขแแแ Transact-SQL COMPRESS แแ DECOMPRESS แคแฃแแฅแชแแแแ.
แแก แคแฃแแฅแชแแแแ แแงแแแแแก แแแแแชแแแแ แจแแแฃแแจแแแก แขแ แแแแชแแฃแ แแแแแแแแก (GZIP แแแแแ แแแแ), แ แแแแแแช แฃแแแ แแงแแก แแแแแซแแฎแแแฃแแ แแแแแชแแแแ แแแแแแฃแแ แแแแงแแคแแแแแแก แจแแแฃแแจแแแก แแ แแแแแแแ แแกแแ แแแแกแแแแก.
Unity XT แจแแแฃแแจแแ, แ แแแแแแช แแ แแ แแก แแฅแกแแแฃแแแฃแ แ SQL Server-แแกแแแแก, แแงแแแแแก แแ แแแ แแแฃแ แแแแแ แแแแก แจแแแแฎแแแก แแแแแชแแแแ แแแแแแแแกแ แแ แจแแแฃแแจแแแกแแแแก. Unity OE 4.1-แแก แแแแแจแแแแแก แจแแแแแ, Unity แแแแแชแแแแ แจแแแฃแแจแแ แฎแแแแแกแแฌแแแแแแ แแแแแแก แจแแแแฎแแแก แแแชแฃแแแแแแแกแแแแก แแ VMFS แแแแแชแแแแ แจแแกแแแแฎแแ แคแแแจ แแฃแแจแ. Unity OE 4.2-แแแ แแแฌแงแแแฃแแ, แจแแแฃแแจแแ แแกแแแ แฎแแแแแกแแฌแแแแแแ แคแแแแฃแ แ แกแแกแขแแแแแแกแแแแก แแ NFS แแแแแชแแแแ แแแฆแแแแแแแกแแแแก แคแแแจ แจแแแแฎแแแก แแฃแแแแจแ.
SQL Server-แแกแแแแก แแแแแชแแแแ แจแแแฃแแจแแแก แแแแแแแก แแ แฉแแแแแ แแแแแแแแแแฃแแแ แ แแแแแแแแ แคแแฅแขแแ แแ. แแก แคแแฅแขแแ แแแ แแแแชแแแก แแแแแชแแแแ แแแแแก แแแแขแแแขแแก แขแแแก, CPU-แก แฎแแแแแกแแฌแแแแ แ แแกแฃแ แกแแแก - แ แแแแ แช แกแแชแแแแ, แแกแแแ แแแแแชแแแแ แแแแแก แกแแ แแแ แแแแ แแ I/O แ แแกแฃแ แกแแแก, แ แแแแแแแช แกแแญแแ แแ SLA-แแก แจแแกแแแแ แฉแฃแแแแแแ. แแแแแแแ, แจแแแแซแแแแ แแแแแแแ แแแแแขแแแแแ แกแแแ แชแแก แแแแแแแแก SQL Server-แแก แแแแแงแแแแแแ แจแแแฃแแจแฃแแ แแแแแชแแแแแแกแแแแก, แแแแ แแ TSQL-แแก GZIP แจแแแฃแแจแแแก แคแฃแแฅแชแแแก แแแแแงแแแแแแ แจแแแฃแแจแฃแแ แแแแแชแแแแแ แแแแแแแแ แกแแแแ แแฃแแแ, แ แแ แแแแแแฎแแก แแแแจแแแแแแแแแ แแแแแขแแแแแ แกแแแ แชแ Unity XT-แแก แจแแแฃแแจแแแก แคแฃแแฅแชแแแแแแแ, แ แแแแแ แฃแแแ แแขแแกแแแแแแก แฃแแแขแแกแแแ แฃแแแแแ แกแแแฃแ แแ. แแแแแ แแแแ.
แแ แแแแแแแแก แจแแแฃแแจแแ แฃแแ แฃแแแแแงแแคแก แกแแแ แชแแก แแแแแแแแก, แแฃ แจแแแแฎแแแก แแแแแฅแขแแ แแแแแชแแแแแ แจแแแฃแแจแฃแแแ แแแแแแฃแ 25%-แแ. แกแแแแ แฉแแ แแแแ แจแแแฃแแจแแแก แจแแกแแแแฎ แแแแแฅแขแแ, แแแแกแแแฆแแ แแ แจแแแชแแแก แแฃ แแ แ แแก แแแแแชแแแแแก, แ แแแแแแ แจแแแฃแแจแแแช แจแแกแแซแแแแแแแ. แแ แฉแแ แแแ แจแแแฃแแจแแ แจแแกแแแแฎแ แแแแแฅแขแแกแแแแก, แแฃ แแก แแ แแแแแแแแก แแแชแฃแแแแแก.
แ แแแแกแแช แแแแแฌแงแแแขแ, แแแแแแงแแแแ แแฃ แแ แ Unity แแแแแชแแแแ แจแแแชแแ แแแ, SQL Server แแแแแชแแแแ แแแแแก แแแแแแ แจแแแฃแแจแแ แแ แแ แแแ, แแแแแแแแแกแฌแแแแ แจแแแแแแ:
- แแแแแชแแแแแ, แ แแแแแแแช แฉแแฌแแ แแแแ Unity แกแแกแขแแแแจแ, แแแแแฌแแแแฃแแแ แฐแแกแขแแก แแแแ , แกแแกแขแแแแก แฅแแจแจแ แจแแแแฎแแแก แจแแแแแ. แแฃแแชแ, แจแแแฃแแจแแแก แแ แแชแแกแ แแ แแฌแงแแแ แแแแแ, แกแแแแ แฅแแจแ แแ แแแกแฃแคแแแแแแแ.
- แจแแแฃแแจแแแก แแแแแแแ แแแแฆแฌแแแ แแ แ แแฎแแแแ Unity XT แจแแแแฎแแแก แ แแกแฃแ แกแแแแกแแแแก, แแ แแแแ แแแแ แแแแกแแแแก แแ แ แแกแฃแ แกแแก แแฎแแแ แแแแแแแแกแแแแก.
- แจแแแฃแแจแแแก แแ แแชแแกแแก แแ แแก, แแ แแแแแ แแแแแ แแแ แแแแ แแแฃแแแ แจแแ แฉแแแแก แแแแแ แแแแแก แแแแแงแแแแแแ, แ แแแ แแแแแแแแแก แจแแกแแซแแแแแแแ แแฃ แแ แ แแแแแชแแแแแแก แจแแแฃแแจแแ. แแฃ แจแแ แฉแแแแก แแแแแ แแแแ แแแแกแแแฆแแ แแแก, แ แแ แแฎแแแแ แแแแแแแแฃแ แ แแแแแแแแแก แแแฆแฌแแแแ แจแแกแแซแแแแแแ, แแแจแแ แจแแแฃแแจแแ แแแแแขแแแแแฃแแแ แแ แแแแแชแแแแแ แแฌแแ แแแ แแฃแแจแ.
- แ แแแแกแแช แแแแแชแแแแแ แจแแแฃแแจแฃแแแ แจแแกแแแแฎ แแแแแแจแ แฉแแฌแแ แแแแ, แแแแแชแแแแ แแแแฃแจแแแแแแก แ แแแแแแแแ แแแแจแแแแแแแแแ แแชแแ แแแแ. แแแ แแแแ, แจแแแฃแแจแแ แฎแแแก แฃแฌแงแแแก แคแแแจ แแแฎแกแแแ แแแแก แชแแแแ แจแแแชแแ แแแแก แแแกแแแ แฉแแฌแแ แแแ แแแแแชแแแแแแก แคแแแแแฃแ แ แ แแแแแแแแแก แจแแแชแแ แแแแ.
แชแฎแ แแแแแแกแ แแ แแแแแฅแกแแแแกแแแแก SQL Server-แจแ แแฌแแ แแแแแแกแ แแ แแแแ แแแแแก แจแแแฃแแจแแแก แจแแกแแฎแแ แแแแแขแแแแแ แแแคแแ แแแชแแแกแแแแก แแฎแแแแ .
แแ แแแแแแแฌแงแแแ, แ แแ แแแแแกแแแแ แ แจแแแฃแแจแแ แแแแแฎแแแก CPU แ แแกแฃแ แกแแแก. แ แแแแกแแช แแแแขแแ แฃแแแ แแแแแแ แแแฆแแแแ, แจแแแฃแแจแแแก แจแแฃแซแแแ แแแแจแแแแแแแแแ แแแแแแแ แแแแฎแแแแแก แจแแกแ แฃแแแแแแ. OLAP แแแขแแแ แแแแก แฉแแฌแแ แแก แแแฆแแ แแแแคแแชแแแแขแแแก แแกแแแ แจแแฃแซแแแแ แจแแแแชแแ แแ แจแแแฃแแจแแแก แฃแแแ แแขแแกแแแแแ SQL Server แแแแแชแแแแ แแแแแจแ.
Dell EMC-แแ แแแแแแแแแแ แแแขแแแชแแฃแ แ แแแแแแแแ Unity แแแกแแแแ แแแแแชแแแแ แ แแแแฃแ แกแแแงแแ แแจแ แจแแแชแแ แแแแก แกแแฉแฅแแ แแก แแแแแงแแแแแแ. แแฃแแแแ แจแแแแ แแแ แแแแแชแแแแแ VMware แแแ แขแฃแแแฃแ แแแแฅแแแแแแ, แคแแแแแแแก แแแแแแ แแแแแ, SQL Server แแแแแชแแแแ แแแแแแแ, Microsoft Hyper-V แแแ แขแฃแแแฃแ แแแแฅแแแแแแ แแ แ.แจ.
แแแแแแแก แจแแแแแแแแ แแฉแแแแ, แ แแ SQL Server log แคแแแแแก แแแแแก แจแแแชแแ แแแ แแแแฅแแแก 10-แฏแแ แแแแแแแแ, แแแแ แ แแแแแชแแแแ แคแแแแ:
- แแแแแชแแแแ แแแแแก แแแแ = 1,49:1 (32,96%)
- แแฃแ แแแแแก แแแชแฃแแแแ = 12,9:1 (92,25%)
SQL Server แแแแแชแแแแ แแแแ แแแฌแแแแแฃแแ แแงแ แแ แ แขแแแแ. แแแแแชแแแแ แแแแแก แคแแแแแแ แแแแฎแแแ แแ แ แขแแแแ, แฎแแแ แขแ แแแแแฅแชแแแก แแฃแ แแแแแแ แแแแฎแแแ แแแแ แแแ. แแแแแชแแแแ แจแแแชแแ แแแแก แขแแฅแแแแแแแแก แแแแแงแแแแแ แแแแแชแแแแ แแแแแก แแแชแฃแแแแแแแแ แแ แแแ แจแแแซแแแแ แฃแแ แฃแแแแแงแแก แจแแแแฎแแแก แแแแแแแ; แแฃแแชแ, แแฅแแแ แฃแแแ แแแแแแแแแกแฌแแแแ แจแแกแ แฃแแแแแแ แแแแแแแ, แ แแแแกแแช แแแแแฌแงแแแขแ, แฉแแ แแแ แแฃ แแ แ แแฃแแแแ แแแ แแแแแชแแแแ แแแแแก แขแแแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแแแชแแแแ แแแแแก แ แแแแฃแ แ แแแแแก แจแแแชแแ แแแ แจแแแซแแแแ แแแแกแฎแแแแแแแแแแก แจแแแแฎแฃแแ แแแแแชแแแแแแก แแแฎแแแแแ, แแแแแแแก แจแแแแแแแแ แแฉแแแแ, แ แแ SQL Server แขแ แแแแแฅแชแแแแแก แแฃแ แแแแแก แจแแแแฎแแแก แกแแแ แชแแก แจแแฃแซแแแ .
แแแแแชแแแแ แจแแแชแแ แแแแก แกแแฃแแแแแกแ แแ แแฅแขแแแ
แกแแแแ แฉแแ แแแแ แแแแแชแแแแ แจแแแชแแ แแแแก แจแแแแฎแแแก แแแแแฅแขแแ, แแแแแแแแแกแฌแแแแ แจแแแแแแ แแแแแแแแแแ:
- แแแแแแงแแแแ แจแแแแฎแแแก แกแแกแขแแแแก แแแแแขแแ แแแแ, แ แแแ แแแ แฌแแฃแแแแ, แ แแ แแแก แแฅแแก แฎแแแแแกแแฌแแแแแ แ แแกแฃแ แกแแแ แแแแแชแแแแ แจแแแชแแ แแแแก แแฎแแ แแแกแแญแแ แแ.
- แแแแแชแแแแ แจแแแชแแ แแแแก แฉแแ แแแ แแ แแแแแ แจแแแแฎแแแก แแแแแฅแขแแกแแแแก แแ แแแ แแฃแแแ. แแแแแแแ แแแ แกแแกแขแแแแก, แ แแแ แแแ แฌแแฃแแแแ, แ แแ แแก แแ แแก แ แแแแแแแแแแฃแ แแแแ แแชแแฃแ แแแ แแแแแจแ, แกแแแแ แฉแแ แแแแ แแแก แแแแแขแแแแ แจแแแแฎแแแก แแแแแแแแจแ.
- Unity XT x80F แแแแแแแแแ แแแแแชแแแแ แจแแแชแแ แแแ แฃแแ แฃแแแแแงแแคแก แกแแแซแแแแ แแก แแแแแแแแก, แแฃ แกแแชแแแแก แแแแงแแคแแแแแแจแ แแแแแชแแแแแ แจแแแฃแแจแฃแแแ แแแแแแฃแ 1%-แแ.
แแแแแชแแแแ แจแแแชแแ แแแ แฌแแแ Unity x80F แแแแแแแแแ, แ แแแแแแแช แแฃแจแแแแแแแ OE 5.0-แแ, แฃแแ แฃแแแแแงแแคแแ แแแแแแแแก, แกแแแแ แแแแแชแแแแแ แจแแแฃแแจแแแแ แแงแ แแแแแแฃแ 25%.
- แกแแแแ แฉแแ แแแแ แแแแแชแแแแ แจแแแชแแ แแแแก แจแแกแแแแฎ แแแแแฅแขแแ, แแแแกแแแฆแแ แแ แจแแแชแแแก แแฃ แแ แ แแแแแฅแขแ แจแแแฃแแจแแแแ แแแแแชแแแแแก. แแแแแชแแแแ แแแ แแแแฃแแ แขแแแแแ, แ แแแแ แแชแแ แแแแแ, แแฃแแแ, แกแฃแ แแแแแ แแ แแ แแแแแ แแแแแชแแแแแ, แฉแแแฃแแแแ แแ แแชแแ แ แกแแ แแแแแแก แแซแแแแ แจแแแฃแแจแแแกแแแ. แแ แฉแแ แแแ แแแแแชแแแแ แจแแแชแแ แแแ แจแแแแฎแแแก แแแแแฅแขแแ, แแฃ แแ แแฅแแแแ แกแแแ แชแแก แแแแแแแ.
- แแแแแแฎแแแแ แจแแ แฉแแแแแ แจแแแฃแแจแแ แคแแแแแก แแแแแชแแแแแแก แแแชแฃแแแแแกแแแแก, แ แแแแแแช แฉแแแฃแแแแ แแ แแแ แแแ แแแฃแแจแแแ.
VMware แแแ แขแฃแแแแแแชแแ
VMware vSphere แแ แแก แแคแแฅแขแฃแ แ แแ แฃแกแแคแ แแฎแ แแแแขแคแแ แแ แแแ แขแฃแแแแแแชแแแกแ แแ แฆแ แฃแแแแแแแ แแแ แแแแกแแแแก. vSphere-แแก แซแแ แแแแแ แแแแแแแแแขแแแแ VMware vCenter แกแแ แแแ แ แแ VMware ESXi แฐแแแแ แแแแแ แ.
vCenter Server แแ แแก แแ แแแแแ แแแ แแแแก แแแแขแคแแ แแ vSphere แแแ แแแแกแแแแก. แแแ แขแแแแ แแแแแ แแแ แแ แ แแกแฃแ แกแแแแก แแ แแแฅแขแแฃแแแ แแแขแแแแแแชแแ. ESXi แแ แแก แฆแแ แแแแแก แฐแแแแ แแแแแ แ, แ แแแแแแช แแแแแกแขแแแแ แแแแ แแแ แแแแแ แคแแแแแฃแ แกแแ แแแ แแแแ. ESXi-แก แแฅแแก แแแ แแแแแ แ แฌแแแแแ แซแแ แแแแ แ แแกแฃแ แกแแแแ แแ แแ แแก แแชแแ แ แแแแแก 150 แแ, แ แแช แแแชแแ แแแก แแแฎแกแแแ แแแแก แแแแฎแแแแแแก. แแก แฃแแ แฃแแแแแงแแคแก แกแแแแแแ แจแแกแ แฃแแแแแก แกแฎแแแแแกแฎแแ แแแแแแแชแแแก แแแขแแแ แแแแกแแแแก แแ แแฎแแ แก แฃแญแแ แก แแซแแแแ แแแ แขแฃแแแฃแ แแแแ แแขแแแแก แแแแคแแแฃแ แแชแแแก - 128 vCPU-แแแ, 6 แขแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ แแ 120 แแแฌแงแแแแแแแ.
แแแแกแแแแแก, แ แแ SQL Server-แแ แแคแแฅแขแฃแ แแ แแแฃแจแแแก แแแแแแแแ แแแ แแแแ แแขแฃแ แแแ, SQL Server แแแแ แแชแแฃแแแ แกแแกแขแแแแ (SQLOS) แฃแแแ แแแแแแก แแแแ แแขแฃแ แแก แแแแแแแ. แแ แแแแแแแ แแแแแแ แแ แแ แแแแแแแแแซแแแแแ แแ แแแ แแแแแ แแแแแ แแแฎแกแแแ แแแแก แฌแแแแแแก (NUMA) แกแแกแขแแแแแแก แแแกแแแแกแแแ แแ แแแ, แแแ แแแแแก, แแแแแแฃแ แแ แแชแแกแแ แแแกแ แแ แคแแแแแฃแ แแ แแชแแกแแ แแแก แจแแ แแก แฃแ แแแแ แแแแแแแก แแแแแแ แแแแกแแแฃแแ แแแแ แแแแจแแแแแแแแแ แแแฎแแ.
แแ แแชแแกแแ แแแ
แแแ แขแฃแแแฃแ แ แแแแฃแจแแแแแแก แแ แแแฃแแ (vCPU) แแ แแก แแแ แขแฃแแแฃแ แ แชแแแขแ แแแฃแ แ แแแแฃแจแแแแแแก แแ แแแฃแแ, แ แแแแแแช แแแแแญแแแฃแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแแ. แแแแแญแแแฃแแ vCPU-แแแแก แกแแแ แแ แ แแแแแแแแ แแแแแแแแแแแ แจแแแแแแแแแ แแ:
Total vCPU = (ะบะพะปะธัะตััะฒะพ ะฒะธัััะฐะปัะฝัั
ัะพะบะตัะพะฒ) * (ะบะพะปะธัะตััะฒะพ ะฒะธัััะฐะปัะฝัั
ัะดะตั ะฝะฐ ัะพะบะตั)แแฃ แแแแแแแแแแ แฃแแ แจแแกแ แฃแแแแ แแแแจแแแแแแแแแแ, VMware แ แแแแแแแแแชแแแก แแซแแแแ, แ แแ แงแแแแ แแแ แขแฃแแแฃแ แแแแ แแขแแ แแแแแญแแแฃแแ vCPU-แแแแก แฏแแแฃแ แ แ แแแแแแแแ แแ แฃแแแ แแฆแแแแขแแแแแแก ESXi แฐแแกแขแแ แฎแแแแแกแแฌแแแแแ แคแแแแแฃแ แ แแแ แแแแแแก แแแแแแ แ แแแแแแแแแก, แแแแ แแ แจแแแแซแแแแ แแแแแ แแแ แแแแแงแแคแแแ vCPU-แแแแก แ แแแแแแแแ, แแฃ แแแแแขแแ แแแแ แแฉแแแแแแก, แ แแ แแแแแฃแงแแแแแแแ CPU แ แแกแฃแ แกแแแ แฎแแแแแกแแฌแแแแแแ.
แกแแกแขแแแแแแ, แ แแแแแแจแแช แฉแแ แแฃแแแ Intel Hyper-Threading แขแแฅแแแแแแแ, แแแแแแฃแ แ แแแ แแแแแแก แ แแแแแแแแ (vCPU) แแ แฏแแ แแแขแแ แคแแแแแฃแ แ แแแ แแแแแแก แ แแแแแแแแแแ. แแ แจแแแแฎแแแแแจแ, แแ แแแแแฃแแแแแ vCPU-แแแแก แกแแแ แแ แ แแแแแแแแ.
SQL Server-แแก แฅแแแแ แแแแแก แแแขแแแ แแแแแ แแแแแแแแ แแแฅแแแแแแก แจแแงแแแแแแแก แชแแแแแแแแแแ. แแแ แแแแ, แแก แแแขแแแ แแแแแ แจแแแซแแแแ แแแฃแจแแแก แแแกแแแแซแแแแแ, แ แแแแแแกแแช แแฅแแ vCPU-แแแแก แแแฆแแแ แแแแแคแแ แแแแ แคแแแแแฃแ CPU-แแแแแ. CPU-แแก แแแแแงแแแแแแก แแแแแแ แฃแแแ แแแแแ แจแแแซแแแแ แแแแแ แแแก แกแแกแขแแแแก แแแแแแแ แแแแขแแ แฃแแแ แแแแแแ, แแแแแ แแแก แแแชแแแแแแก แแแแแแแ แแ แจแแแแแ แฉแฃแแแก แแแแแแแขแฃแ แ แจแแกแ แฃแแแแ.
Intel Hyper-Threading, แ แแแแ แช แฌแแกแ, แแฃแแฏแแแแกแแแก แฐแแกแขแแก แกแแแ แแ แแแแขแแ แฃแแแ แแแแแแแก 10%-แแแ 30%-แแแ, แ แแช แแแ แแฃแแแแก vCPU-แก แคแแแแแฃแ CPU-แก แแแแแคแแ แแแแแก 1,1-แแแ 1,3-แแแ. VMware แแแ แฉแแแ แฉแแ แแแ Hyper-Threading UEFI BIOS-แจแ แจแแซแแแแแกแแแแแแ แแ, แ แแแ ESXi-แ แจแแซแแแก แแกแแ แแแแแแก แแ แขแแฅแแแแแแแแ. VMware แแกแแแ แ แแแแแแแแแชแแแก แฃแฌแแแก แกแแคแฃแซแแแแแ แขแแกแขแแ แแแแก แแ แแแแแขแแ แแแแก SQL Server-แแก แแแขแแแ แแแแกแแแแก Hyper-Threading-แแก แแแแแงแแแแแแกแแก.
แแแฎแกแแแ แแแ
แแแแฅแแแก แงแแแแ แแแแแแแแ แแแ แกแแ แแแ แ แแงแแแแแก แแแฎแกแแแ แแแแก แแ แแแ แแแแแ แแแแ แฌแแแแแแก (NUMA) แแ แฅแแขแแฅแขแฃแ แแก แแแแแแ แแแฎแกแแแ แแแแกแ แแ แแ แแชแแกแแ แแแก แจแแ แแก แแแแฃแแแแแชแแแกแแแแก. NUMA แแ แแก แขแแฅแแแแแก แแ แฅแแขแแฅแขแฃแ แ แกแแแ แแ แแแฎแกแแแ แแแแกแแแแก, แ แแแแแแช แแฎแแ แชแแแแแแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแแแแแแแก แแแงแแคแแก แคแแแแแฃแ แแ แแชแแกแแ แแแก แจแแ แแก. NUMA แแแแแซแ แแ แแก แแ แแ แแ แแแขแ CPU แกแแแแขแ แแแแแงแแคแแแ แแแฎแกแแแ แแแแก แแแแแแแ แแ แแแ.
NUMA แคแแ แแแ แแแแฎแแแฃแแ แแแแ แแงแ แแแแ แแแฌแแแฃแแแก แแแแแแแแแแแจแ. NUMA-แก แจแแแแ แแแแแ แกแแ แแฃแแ แแแฌแแแแแ แแ แแแแแแ แแแแแฃแแแ แกแฎแแแแแกแฎแแ แแแแฌแแแแแแแกแแแ แแแแฎแแ แชแแแแแแแ. แแแ แขแฃแแแแแแแฃแ แแแ แแแแจแ, NUMA-แก แกแแ แแฃแแ แแกแแแ แแแแแกแแแฆแแ แแแ แแแแคแแแฃแ แแชแแแก แแแ แแแแขแแแแกแ แแ แคแแแแแแก แ แแแแแแแแแ - แแแแ แแขแฃแ แแแแ แฐแแแแ แแแแแ แแก แแแแแแ แกแขแฃแแ แแก แแแแ แแชแแฃแ แกแแกแขแแแแแแ แแ แแแแแก SQL Server แแแแแแแชแแแแแ. NUMA แขแแฅแแแแแก แแ แฅแแขแแฅแขแฃแ แแก แแแ แแแ แแแแแ แแแ แแฃแชแแแแแแแแ แแแแแกแแแแ แ SQL Server DBA-แกแแแแก, แ แแแแแแช แแฃแจแแแแก แแแ แขแฃแแแแแแแฃแ SQL Server แแแกแขแแแชแแแแ.
แแแแ แ แแแแแแแแแก แแแ แแแแแแก แแฅแแแ แกแแ แแแ แแแแ แฃแคแ แ แแแแ แแคแแฅแขแฃแ แแแแก แแแกแแฆแฌแแแแ, Microsoft-แแ แฌแแ แแแแแแ SoftNUMA. SoftNUMA แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แกแแจแฃแแแแแแก แแแซแแแแ แแแงแแ CPU แฎแแแแแกแแฌแแแแแ แ แแกแฃแ แกแแแ แแ แแ NUMA-แจแ แ แแแแแแแแ SoftNUMA แแแแแซแแ. VMware-แแก แแแฎแแแแแ, SoftNUMA แแแแกแแแแแแ VMware-แแก แแแ แขแฃแแแฃแ NUMA (vNUMA) แขแแแแแแแแแกแแแ แแ แจแแฃแซแแแ แจแแแแแแแ แแแขแแแแแแชแแ แแแฃแฌแแแก แแแแแชแแแแ แแแแแก แซแ แแแแก แแแกแจแขแแแฃแ แแแแก แแ แจแแกแ แฃแแแแแก แกแแแฃแจแแ แแแขแแแ แแแแก แฃแแแขแแกแแแแกแแแแก...
SQL Server-แแ VMware แแแ แขแฃแแแแแแชแแแกแแก แแแแแแงแแแแ:
- แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแแแขแแ แแแแ SQL Server แแแแแชแแแแ แแแแแก แซแ แแแแกแแแแก แแแแแแ แแแฎแกแแแ แแแแก แ แแกแฃแ แกแแแแก แแแแแกแแแแแแแ. แแก แแ แแแแแแ แแฌแแแแก I/O แแแแ แแชแแแแแก แแแแ แแแก แแ แจแแกแ แฃแแแแแก แจแแแชแแ แแแแก.
- แแฃแจแแแแแก แแแกแแฃแแฏแแแแกแแแแแ, แแแแแแแ แแแชแแแแ แแแฎแกแแแ แแแแก แแแแคแแแฅแขแ แแแ แขแฃแแแฃแ แแแแฅแแแแแก แจแแ แแก แแแฎแกแแแ แแแแก แแแแแขแแแ แแแแก แแแแแแแ แแกแแชแแแแแแแ ESXi แฐแแกแขแแก แแแแแแ.
- แจแแแแแฌแแแ แแแแ แแขแฃแ แแก NUMA แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแแแแฌแแแแแ, แ แแแ แแแแแแแแแก แแแฎแกแแแ แแแแก แแแฅแกแแแแแฃแ แ แ แแแแแแแแ, แ แแแแแแช แจแแแซแแแแ แแแแแแญแแก แแแ แขแฃแแแฃแ แแแแฅแแแแก NUMA แคแแแแแฃแ แกแแแฆแแ แแแจแ.
- แแฃ แแแแแแแขแฃแ แ แจแแกแ แฃแแแแแก แแแฆแฌแแแ แฃแแแ แแแแแกแ แแแแแแแ, แแแแแฎแแแแ แแแฎแกแแแ แแแแก แแแฏแแแจแแ แแแแแงแแคแแแ แแแฎแกแแแ แแแแก แขแแแ. แแแ แแแแขแ แแก แแก แแแ แแแแขแ แ แฃแแ แฃแแแแแงแแคแก, แ แแ แแแ แขแฃแแแฃแ แ แแแแฅแแแ แแฆแแแก แแฎแแแแ แคแแแแแฃแ แแแฎแกแแแ แแแแก.
แแแ แขแฃแแแแแแแฃแแ แกแแชแแแ
แแแ แขแฃแแแแแแแฃแ แแแ แแแแจแ แแแฎแกแแแ แแแแก แแแงแแแแแ แแแแแฎแแแก แจแแแแฎแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แชแแแแแก. แ แแแแ แช NUMA-แก แจแแแแฎแแแแแจแ, แแฅแแแ แฃแแแ แแแกแแแแแ, แแฃ แ แแแแ แแฃแจแแแแก I/O แกแฎแแแแแกแฎแแ แแแแแแแ - แแ แจแแแแฎแแแแแจแ, VM-แจแ แแแแแแแชแแแแแ แแแฌแงแแแฃแแ, แแแคแแ แแแชแแแก แคแแแแแฃแ แฌแแแแแฎแแแแแ แแ แฉแแฌแแ แแแแ แแฃแแแแ แจแแกแแแแฎ แกแแจแฃแแแแแแแแ.
vSphere แแแแแแแแแ แฃแแแ แแ แแแ แแแแขแก แแแฎแกแแแ แแแแก แแแแคแแแฃแ แแชแแแกแแแแก, แ แแแแแแกแแช แแฅแแ แกแแกแแ แแแแแ แแแแแแแชแแแแ SQL Server-แแก แแแแฎแแ แชแแแแแแแจแ Unity XT แแแกแแแแ. FS VMFS แแ แแก แแแแแชแแแแ แจแแแแฎแแแก แงแแแแแแ แคแแ แแแ แแแแแงแแแแแฃแแ แแแแแแ แแแแแแก แจแแแแฎแแแก แกแแกแขแแแแแจแ, แ แแแแ แแชแแ Unity XT. Unity XT แแแกแแแ แแ แแก แฅแแแแ แแแ แฃแกแ, แ แแแแแแช แจแแแแแแ แคแแแแแฃแ แ แแแกแแแแแกแแแ, แ แแแแแแแช แแแแแแแแแแแแ vSphere-แแก แแแแ , แ แแแแ แช แแแแแแฃแ แ แแแกแแแแ (แขแแแแแ). Unity XT แขแแแแแ แคแแ แแแขแแ แแแฃแแแ, แ แแแแ แช VMFS แขแแแแแ ESXi แฐแแแแ แแแแแ แแก แแแแ . VMware แแแแแแแกแขแ แแขแแ แแแ แฅแแแแแ แแ แ แแ แแแข แแแ แขแฃแแแฃแ แแแกแแก (VMDK), แ แแแแแแแช แฌแแ แแแแแแแแแแ แกแขแฃแแ แแก แแแแ แแชแแฃแ แกแแกแขแแแแจแ. RDM แกแแจแฃแแแแแแก แแซแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแก แแแ แแแแแ แฌแแแแแ แฐแฅแแแแแก Unity XT แแแแแแก แกแแชแแแจแ (FC แแ iSCSI-แแก แกแแจแฃแแแแแแ) VMFS แคแแ แแแขแแ แแแแก แแแ แแจแ. VMFS แแ RDM แขแแแก แจแแฃแซแแแ แฃแแ แฃแแแแแงแแก แแแแแ แขแ แแแแแฅแชแแแก แแแแขแแ แฃแแแ แแแแแแ.
ESXi-แกแแแแก NFS-แแ แแแคแฃแซแแแแฃแแ แจแแแแฎแแแกแแแแก, Dell EMC แแแ แฉแแแ แแแแแแงแแแแ VMware NFS แแแแแแ แแแแแจแแฃแแแแแก NFS แคแแแแฃแ แ แกแแกแขแแแแแแก แแแชแแแแ. แแแ แขแฃแแแฃแ แ แแแแฅแแแ, แ แแแแแแช แแฃแจแแแแก SQL แกแแ แแแ แแ แแ แแงแแแแแก VMDK-แก NFS แแแแแชแแแแ แแแฆแแแแแจแ, แแ แแชแแก แฅแแแแแแแแ แ NFS แคแแแแก แจแแกแแฎแแ. แกแขแฃแแแ แ แแแแ แแชแแฃแแ แกแแกแขแแแ แแแแแฎแแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแก, แ แแแแ แช แคแแแแแฃแ แกแแ แแแ แก, แ แแแแแแช แแฃแจแแแแก Windows Server แแ SQL Server. NFS แแแแแชแแแแ แกแแชแแแแแแ แแ แแ แแก แแฎแแ แแแญแแ แแแ แแแแแแ แแแฃแแ แแแกแแแแ แแแแกแขแแ แฃแแ แแแแแแแแแแแก แแแแคแแแฃแ แแชแแแกแแแแก.
VMware vSphere แแแ แขแฃแแแฃแ แ แขแแแแแ (VVols) แแแแแแแแแ แฃแคแ แ แแแ แชแแแแแแ แแแแขแ แแแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แแแแแแ, แแแแแฃแแแแแแแแ แซแแ แแแแแ แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แฌแแ แแแแแแแแกแแแ (แ แแแแ แแชแแ แขแแแแแ แแ แคแแแแฃแ แ แกแแกแขแแแแแ). แแแกแแแแ แแแคแฃแซแแแแฃแแ แ แแแแแแแชแแ VVols-แแ แแฎแแ แแแญแแ แแแแ VVol 2.0-แแ แแแฌแงแแแฃแแ (vSphere 6.5). VVol แแแกแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก RDM แแแกแแแก แแแชแแแแ, แ แแแ แฃแแ แฃแแแแแงแแก แแแกแแแก แ แแกแฃแ แกแ SQL Failover Cluster-แแก แแแแแแแแแ แแแฌแงแแแฃแแ vSphere 6.7-แแ, แแฃแแแแแ SCSI แกแแ แแแแ แแ แแกแแแก แแฎแแ แแแญแแ แแ.
แแแ แขแฃแแแแแแแฃแแ แฅแกแแแแแ
แแแ แขแฃแแแฃแ แกแแแงแแ แแจแ แฅแกแแแ แแแฐแงแแแแ แแแแแ แแแแแแฃแ แชแแแแแแก, แ แแแแ แช แคแแแแแฃแ แกแแแงแแ แแจแ, แแแแ แแ แแงแแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก แแ แแ แ แคแแแแแฃแ แแแแแแแแก แแ แแแแชแแแขแ แแขแแ แแแก. แฅแกแแแแก แจแแงแแแแแแแก แแแแแแแ SQL Server-แแก แแแขแแแ แแแแแ แจแแแซแแแแ แแแแจแแแแแแแแแ แแแแกแฎแแแแแแแแแแก. แฅแกแแแแก แแฃแจแแแแแก แแแขแ แแแแก แแแแแขแแ แแแแ แแ แกแแแฃแ แแแขแแแ แแแแแ แแ แแแ แแแ แแแแแ แแแแ แกแแขแแกแขแ แกแแกแขแแแแก แฌแแ แแแแแแแแแแแแแแ แแแ แแแแแก แแแแแแแแแแแจแ แแฎแแแ แแแ แแแ แขแฃแแแฃแ แ แฅแกแแแแก แจแแฅแแแแก.
SQL Server-แแ VMware แแแ แขแฃแแแแแแชแแแก แแแแแงแแแแแแกแแก แแแแแแแแแกแฌแแแแ แจแแแแแแ:
- แ แแแแ แช แกแขแแแแแ แขแฃแแ, แแกแแแ แแแแแฌแแแแแฃแแ แแแ แขแฃแแแฃแ แ แแแแชแแแขแ แแขแแ แแแ แฃแแ แฃแแแแแงแแคแแ SQL Server-แแก แแแแ แแแแฎแแแแแ แคแฃแแฅแชแแแแแ แแแแก.
- แแแแแฏแแแแขแแก, vSphere vMotion-แแกแ แแ แฅแกแแแแก แแแฎแกแแแ แแแแก แขแ แแคแแแแก แแแแแแฃแ แแ แแแแชแแแแแแแแแกแแแแก แแแแแแงแแแแ VLAN แขแแแแ แแแ แแ แแแ แขแฃแแแฃแ แ แแแแแ แแแแก แแแ แขแแก แฏแแฃแคแแแ.
- VMware แแแแแแแแแ แแแ แฉแแแ, แฉแแ แแแ แแแแ แฉแแ แฉแแแแ แแแ แขแฃแแแฃแ แแแแแแ แแแแแแแแ, แกแแแแช แฉแแ แแฃแแแ vSphere vMotion แขแ แแคแแแ แแ iSCSI แขแ แแคแแแ.
- แแแแแแแ, แแแฐแงแแแแ แฅแกแแแแก แแแแแแแแแแก แกแขแฃแแ แแก แแแแ แแชแแฃแแ แกแแกแขแแแแแแกแ แแ แแแแ แแขแฃแ แแก แจแแกแแฎแแ.
แแแกแแแแ
SQL Server แแแแแชแแแแ แแแแแก แแแ แแแ แกแฃแ แฃแคแ แ แแแแ แแ แ แแฃแแ แฎแแแแ. SQL Server 2019-แจแ Microsoft-แแ แแแแฃแแฏแแแแกแ SQL Server-แแก แซแแ แแแแแ แคแฃแแฅแชแแแแ แแ แแแแแแขแ แแฎแแแแ, แ แแแแ แแชแแ แแแแ แแแแแชแแแแแแก แแแขแแแ แแแแก แแฎแแ แแแญแแ แ Apache Spark-แแ แแ HDFS-แแ. Dell EMC, Microsoft-แแแ แแแ แขแแแแ แแแแ, แแแ แซแแแแแก SQL Server-แแก แแแ แแแแกแแแแก แกแแญแแ แ แแแคแ แแกแขแ แฃแฅแขแฃแ แฃแแ แแแแแแแแแขแแแแก - แกแแ แแแ แแแแก, แจแแแแฎแแแกแ แแ แฅแกแแแแแแก แฃแแ แฃแแแแแงแแคแแก.
แฉแแแ แแฎแแแแแ แแ แแแก แแแแจแแแแแแแแ แแ แแแก แแ แกแแแฃแแ แแแแก แแแแแแแ แฆแแ แแแฃแแแแแก (TCO) แจแแแชแแ แแแแก, แ แแแแกแแช แจแแแแฎแแแกแ แแ แแแแแชแแแแ แแแแแก แแ แแคแแกแแแแแแแแ แแ แแแ แแฃแจแแแแแ SQL Server-แแกแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แฃแแ แแแแแฌแงแแแขแแแแแแแแก แจแแกแแฅแแแแแแ แกแแแ แแ แกแแชแแแแก แแแแขแคแแ แแแแแ. Dell EMC Unity XT แงแแแแ แคแแแจ แแแกแแแ แแ แแก แกแแจแฃแแแ แแแแแก แแแแแฌแงแแแขแ, แ แแแแแแช แจแแกแแคแแ แแกแแ SQL Server แแแแแแแแแ แแแแกแแแแก แแ แแแแแแแกแขแ แแขแแ แแแแกแแแแก, แ แแแแแแกแแช แกแญแแ แแแแแ แแแฆแแแ แจแแกแ แฃแแแแ แแ แแแแแแ แจแแงแแแแแแ. แจแแฅแแแแแแ แงแแแแ แคแแแจ แแแกแแแ แแแกแแจแแแแแ, Unity XT All-Flash แแฎแแ แก แฃแญแแ แก แแ CPU-แก, แแ แแแแ แแแแขแ แแแแ แแก แแแแคแแแฃแ แแชแแแก แแ แแ แแแแ แแแ แแแแแ แแแขแแแแแแชแแแก.
แกแฃแ แฃแคแ แ แแ แฃแคแ แ แแแ แแแแ แแ แแแแแแแชแแแแ แแแแแแแแ SQL Server แแแ แแแแก แแแ แขแฃแแแแแแชแแแก. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแ แขแฃแแแแแแชแแ แแแแขแแแก แกแฎแแ แแแแแแแแก แคแแแแก แแ แฅแแขแแฅแขแฃแ แแก แแแกแขแแก, แแก แแแแจแแแแแแแแ แกแแ แแแแแแก แแซแแแแ. แแแแแแแแแแแ, แ แแ แแฅแแแแแแแก แงแแแแแแ แฎแจแแ แแ แแแแแงแแแแแฃแแ VMware แคแฃแแฅแชแแแแ แแ แฎแแแกแแฌแงแแแแ, แ แแแแแแแช แแแแแ แแ แแก แฌแแ แแแแแแแแแ, แแแแแกแแแแแแ SQL Server แแแ แแแแจแ. แฉแแแ แแกแแแ แแแ แฉแแแ แ แแกแฃแ แกแแแแก แแแฃแแแแก แฃแคแ แ แแแขแแแฃแ แ แแแคแแ แแแชแแแกแแแแก.
แกแแกแแ แแแแแ แแแฃแแแแ
Dell EMC
- (แแ แแแฃแฅแขแแก แแแแ แแ)
- (YouTube)
VMware
microsoft
แฌแงแแ แ: www.habr.com