Skip to content

C
CSDN-技能树

梦想橡皮擦 / CSDN-技能树
与 Fork 源项目一致

Fork自 CSDN 技术社区 / CSDN-技能森林

通知 7
Star 2
Fork 0
C
CSDN-技能树
切换分支/标签
查找文件 普通视图历史永久链接Permalink
云原生_tree.txt 417.6 KB
Newer Older
L
update node level  
luxin 已提交
1 
云原生 --> ( 难度等级: [0, 1) || 挂载数据: 无 )
L
update node level  
luxin 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 
├── 云原生初阶-应用开发 --> ( 难度等级: [0.0, 0.1667) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.0, 0.0417) || 挂载数据: 无 ) 
│   │   ├── Cloud Events --> ( 难度等级: [0.0, 0.0012) || 挂载数据: 无 ) 
│   │   ├── Serverless Framework --> ( 难度等级: [0.0012, 0.0025) || 挂载数据: 无 ) 
│   │   ├── Serverless Devs --> ( 难度等级: [0.0025, 0.0037) || 挂载数据: 无 ) 
│   │   ├── FaaS Serverless --> ( 难度等级: [0.0037, 0.0049) || 挂载数据: 无 ) 
│   │   │   ├── Nuclio --> ( 难度等级: [0.0037, 0.0039) || 挂载数据: 无 ) 
│   │   │   ├── Kubeless --> ( 难度等级: [0.0039, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubeless概述 --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Kubeless --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置客户端 --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署函数 --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   └── Kubeless UI --> ( 难度等级: [0.004, 0.004) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Function --> ( 难度等级: [0.004, 0.0041) || 挂载数据: blog: 2 ) 
│   │   │   │       ├── 函数部署 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       ├── 函数调用 --> ( 难度等级: [0.004, 0.0041) || 挂载数据: 无 ) 
│   │   │   │       └── 自动扩展 --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: blog: 1 ) 
│   │   │   ├── Fission --> ( 难度等级: [0.0041, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Fission --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Fission Chart --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 命令行工具 --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   │   └── Hello Fission --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 深入探讨Fission --> ( 难度等级: [0.0041, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   │   └── Environment --> ( 难度等级: [0.0041, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行模式 --> ( 难度等级: [0.0042, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Poolbased模式 --> ( 难度等级: [0.0042, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   │   └── New Deploy模式 --> ( 难度等级: [0.0042, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   └── Workflows --> ( 难度等级: [0.0042, 0.0043) || 挂载数据: 无 ) 
│   │   │   │       ├── Workflows定义 --> ( 难度等级: [0.0042, 0.0043) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置Workflows --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │       └── Fortune Whale --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   ├── OpenFaas --> ( 难度等级: [0.0043, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   ├── 初识OpenFaaS --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   │   └── 图形界面 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenFaaS函数 --> ( 难度等级: [0.0043, 0.0044) || 挂载数据: blog: 7 ) 
│   │   │   │   │   ├── 抽象方式 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 函数模板 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 构建函数 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: blog: 4 ) 
│   │   │   │   │   └── 推送镜像 --> ( 难度等级: [0.0043, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   ├── Watchdog --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工作原理 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置Watchdog --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: blog: 2 ) 
│   │   │   │   │   └── ofwatchdog --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   ├── 监控 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 监控指标 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 监控面板 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   └── 监控预警 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   ├── 弹性扩展 --> ( 难度等级: [0.0044, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基于Alertmanager扩展 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   └── 基于HPA扩展 --> ( 难度等级: [0.0044, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   └── 函数应用市场 --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   ├── OpenWhisk --> ( 难度等级: [0.0045, 0.0047) || 挂载数据: 无 ) 
│   │   │   │   ├── Hello Whisk --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   ├── 逻辑架构 --> ( 难度等级: [0.0045, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Namespace --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Package --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Action --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── Feed --> ( 难度等级: [0.0045, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   └── Rule --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统架构 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Kubernetes部署 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Kubernetes集群 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群基础设置 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建访问入口 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署组件 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 加载系统配置 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 测试集群 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   └── 删除集群 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm部署 --> ( 难度等级: [0.0046, 0.0047) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 安装Helm --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 环境配置 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Chart --> ( 难度等级: [0.0046, 0.0047) || 挂载数据: blog: 4 ) 
│   │   │   │   │   └── 管理应用 --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │   └── 蛋糕管理服务 --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 开发环境 --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 定义Action --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 创建Package --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 部署Action --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       └── 发布API --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   └── Fn Project --> ( 难度等级: [0.0047, 0.0049) || 挂载数据: 无 ) 
│   │   ├── 踏上征途 --> ( 难度等级: [0.0049, 0.0061) || 挂载数据: 无 ) 
│   │   ├── 无服务器初探 --> ( 难度等级: [0.0061, 0.0074) || 挂载数据: 无 ) 
│   │   │   ├── 来龙去脉 --> ( 难度等级: [0.0061, 0.0064) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向服务的架构与微服务 --> ( 难度等级: [0.0061, 0.0063) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 从SOA到微服务 --> ( 难度等级: [0.0061, 0.0062) || 挂载数据: 无 ) 
│   │   │   │   │   └── 微服务的价值与挑战 --> ( 难度等级: [0.0062, 0.0063) || 挂载数据: 无 ) 
│   │   │   │   └── 软件设计 --> ( 难度等级: [0.0063, 0.0064) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器架构原则 --> ( 难度等级: [0.0064, 0.0067) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据需要使用计算服务执行代码 --> ( 难度等级: [0.0064, 0.0065) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写单一用途的无状态函数 --> ( 难度等级: [0.0065, 0.0066) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计基于推送的、事件驱动的管道 --> ( 难度等级: [0.0066, 0.0066) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建更厚、更强大的前端 --> ( 难度等级: [0.0066, 0.0067) || 挂载数据: 无 ) 
│   │   │   │   └── 拥抱第三方服务 --> ( 难度等级: [0.0067, 0.0067) || 挂载数据: 无 ) 
│   │   │   ├── 从服务器过渡到服务 --> ( 难度等级: [0.0067, 0.007) || 挂载数据: 无 ) 
│   │   │   └── 无服务器的利与弊 --> ( 难度等级: [0.007, 0.0074) || 挂载数据: 无 ) 
│   │   │       ├── 决策驱动因素 --> ( 难度等级: [0.007, 0.0072) || 挂载数据: 无 ) 
│   │   │       └── 什么时候使用无服务器 --> ( 难度等级: [0.0072, 0.0074) || 挂载数据: blog: 10 ) 
│   │   ├── .架构与模式 --> ( 难度等级: [0.0074, 0.0086) || 挂载数据: 无 ) 
│   │   │   ├── 使用场景 --> ( 难度等级: [0.0074, 0.0078) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用程序后端 --> ( 难度等级: [0.0074, 0.0074) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据处理与操作 --> ( 难度等级: [0.0074, 0.0075) || 挂载数据: 无 ) 
│   │   │   │   ├── 实时分析 --> ( 难度等级: [0.0075, 0.0076) || 挂载数据: 无 ) 
│   │   │   │   ├── 遗留API代理 --> ( 难度等级: [0.0076, 0.0076) || 挂载数据: 无 ) 
│   │   │   │   ├── 计划服务 --> ( 难度等级: [0.0076, 0.0077) || 挂载数据: 无 ) 
│   │   │   │   └── 机器人（Bot）和技能（Skill） . --> ( 难度等级: [0.0077, 0.0078) || 挂载数据: 无 ) 
│   │   │   ├── 架构 --> ( 难度等级: [0.0078, 0.0082) || 挂载数据: 无 ) 
│   │   │   │   ├── 计算即后端 --> ( 难度等级: [0.0078, 0.0078) || 挂载数据: 无 ) 
│   │   │   │   ├── 遗留API代理 --> ( 难度等级: [0.0078, 0.0079) || 挂载数据: 无 ) 
│   │   │   │   ├── 混合 --> ( 难度等级: [0.0079, 0.008) || 挂载数据: 无 ) 
│   │   │   │   ├── GraphQL . --> ( 难度等级: [0.008, 0.008) || 挂载数据: 无 ) 
│   │   │   │   ├── 计算即胶水 --> ( 难度等级: [0.008, 0.0081) || 挂载数据: 无 ) 
│   │   │   │   └── 实时处理 --> ( 难度等级: [0.0081, 0.0082) || 挂载数据: 无 ) 
│   │   │   └── 模式 --> ( 难度等级: [0.0082, 0.0086) || 挂载数据: 无 ) 
│   │   │       ├── 命令模式 --> ( 难度等级: [0.0082, 0.0083) || 挂载数据: 无 ) 
│   │   │       ├── 消息传输模式 --> ( 难度等级: [0.0083, 0.0083) || 挂载数据: blog: 1 ) 
│   │   │       ├── 优先级队列模式 --> ( 难度等级: [0.0083, 0.0084) || 挂载数据: 无 ) 
│   │   │       ├── 扇出模式 --> ( 难度等级: [0.0084, 0.0085) || 挂载数据: 无 ) 
│   │   │       └── 管道和过滤器模式 --> ( 难度等级: [0.0085, 0.0086) || 挂载数据: 无 ) 
│   │   ├── 建立无服务器应用程序 --> ( 难度等级: [0.0086, 0.0098) || 挂载数据: 无 ) 
│   │   │   ├── 小时视频 --> ( 难度等级: [0.0086, 0.0088) || 挂载数据: 无 ) 
│   │   │   │   ├── 总体需求 --> ( 难度等级: [0.0086, 0.0086) || 挂载数据: 无 ) 
│   │   │   │   ├── Amazon Web Services（AWS） --> ( 难度等级: [0.0086, 0.0086) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建第一个Lambda函数 --> ( 难度等级: [0.0086, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名你的Lambda --> ( 难度等级: [0.0087, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地测试 --> ( 难度等级: [0.0087, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署到AWS --> ( 难度等级: [0.0087, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接S3 和Lambda --> ( 难度等级: [0.0087, 0.0088) || 挂载数据: 无 ) 
│   │   │   │   ├── 在AWS中测试 --> ( 难度等级: [0.0088, 0.0088) || 挂载数据: 无 ) 
│   │   │   │   └── 观察日志 --> ( 难度等级: [0.0088, 0.0088) || 挂载数据: 无 ) 
│   │   │   ├── 配置Simple Notification Service --> ( 难度等级: [0.0088, 0.0091) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 连接SNS和S --> ( 难度等级: [0.0088, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   ├── 从SNS接收电子邮件 --> ( 难度等级: [0.0089, 0.009) || 挂载数据: 无 ) 
│   │   │   │   └── 测试SNS --> ( 难度等级: [0.009, 0.0091) || 挂载数据: 无 ) 
│   │   │   ├── 设置视频权限 --> ( 难度等级: [0.0091, 0.0093) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建第二个函数 --> ( 难度等级: [0.0091, 0.0092) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置与安全 --> ( 难度等级: [0.0092, 0.0092) || 挂载数据: 无 ) 
│   │   │   │   └── 测试第二个函数 --> ( 难度等级: [0.0092, 0.0093) || 挂载数据: 无 ) 
│   │   │   ├── 生成元数据 --> ( 难度等级: [0.0093, 0.0096) || 挂载数据: 无 ) 
│   │   │   └── 收尾 --> ( 难度等级: [0.0096, 0.0098) || 挂载数据: 无 ) 
│   │   ├── 设置你的云服务 --> ( 难度等级: [0.0098, 0.011) || 挂载数据: 无 ) 
│   │   │   └── 安全模型和身份管理 --> ( 难度等级: [0.0098, 0.011) || 挂载数据: 无 ) 
│   │   │       └── 创建和管理IAM用户 --> ( 难度等级: [0.0098, 0.011) || 挂载数据: 无 ) 
│   │   ├── 深入核心 --> ( 难度等级: [0.011, 0.0123) || 挂载数据: 无 ) 
│   │   ├── 身份认证和授权 --> ( 难度等级: [0.0123, 0.0135) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器环境中的身份认证 --> ( 难度等级: [0.0123, 0.0126) || 挂载数据: 无 ) 
│   │   │   │   ├── 无服务器方法 --> ( 难度等级: [0.0123, 0.0124) || 挂载数据: 无 ) 
│   │   │   │   ├── Amazon Cognito --> ( 难度等级: [0.0124, 0.0125) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Auth0 --> ( 难度等级: [0.0125, 0.0126) || 挂载数据: 无 ) 
│   │   │   ├── 为 24 小时视频增加身份认证 --> ( 难度等级: [0.0126, 0.0129) || 挂载数据: 无 ) 
│   │   │   │   ├── 计划 --> ( 难度等级: [0.0126, 0.0126) || 挂载数据: 无 ) 
│   │   │   │   ├── 直接调用Lambda --> ( 难度等级: [0.0126, 0.0127) || 挂载数据: 无 ) 
│   │   │   │   ├── 小时视频网站 --> ( 难度等级: [0.0127, 0.0127) || 挂载数据: 无 ) 
│   │   │   │   ├── Auth0 配置 --> ( 难度等级: [0.0127, 0.0128) || 挂载数据: 无 ) 
│   │   │   │   ├── 在网站中加入Auth0 --> ( 难度等级: [0.0128, 0.0128) || 挂载数据: 无 ) 
│   │   │   │   └── 测试Auth0 的集成 --> ( 难度等级: [0.0128, 0.0129) || 挂载数据: 无 ) 
│   │   │   ├── 与AWS集成 --> ( 难度等级: [0.0129, 0.0132) || 挂载数据: 无 ) 
│   │   │   │   ├── 用户信息Lambda --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: 无 ) 
│   │   │   │   ├── API Gateway --> ( 难度等级: [0.0129, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 作为接口的API Gateway --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: blog: 10 ) 
│   │   │   │   │   │   ├── 和AWS服务集成 --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: blog: 10 ) 
│   │   │   │   │   │   └── 脚本 --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建资源和方法 --> ( 难度等级: [0.0129, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置方法执行 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 更新网站 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   └── 优化网关 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 限制 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │       └── 缓存 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   ├── 映射 --> ( 难度等级: [0.013, 0.0131) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过API Gateway调用Lambda --> ( 难度等级: [0.0131, 0.0131) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义授权方 --> ( 难度等级: [0.0131, 0.0132) || 挂载数据: 无 ) 
│   │   │   └── 委托令牌 --> ( 难度等级: [0.0132, 0.0135) || 挂载数据: 无 ) 
│   │   │       ├── 真实案例 --> ( 难度等级: [0.0132, 0.0133) || 挂载数据: 无 ) 
│   │   │       └── 开通委托令牌 --> ( 难度等级: [0.0133, 0.0135) || 挂载数据: 无 ) 
│   │   ├── 编排者Lambda --> ( 难度等级: [0.0135, 0.0147) || 挂载数据: 无 ) 
│   │   │   ├── Lambda内幕 --> ( 难度等级: [0.0135, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件模型和源 --> ( 难度等级: [0.0135, 0.0135) || 挂载数据: 无 ) 
│   │   │   │   ├── 推送和拉取事件模型 --> ( 难度等级: [0.0135, 0.0136) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发执行 --> ( 难度等级: [0.0136, 0.0136) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器重用 --> ( 难度等级: [0.0136, 0.0136) || 挂载数据: 无 ) 
│   │   │   │   └── 冷Lambda和暖Lambda --> ( 难度等级: [0.0136, 0.0137) || 挂载数据: blog: 2 ) 
│   │   │   ├── 编程模型 --> ( 难度等级: [0.0137, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数处理程序 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件对象 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 上下文对象 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 回调函数 --> ( 难度等级: [0.0137, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 代码开发 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── Handler --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 执行上下文 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志输出 --> ( 难度等级: [0.0138, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常处理 --> ( 难度等级: [0.0139, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   └── 无状态 --> ( 难度等级: [0.0139, 0.0139) || 挂载数据: 无 ) 
│   │   │   ├── 版本管理、别名和环境变量 --> ( 难度等级: [0.0139, 0.0141) || 挂载数据: 无 ) 
│   │   │   │   ├── 版本管理 --> ( 难度等级: [0.0139, 0.014) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 别名 --> ( 难度等级: [0.014, 0.014) || 挂载数据: 无 ) 
│   │   │   │   └── 环境变量 --> ( 难度等级: [0.014, 0.0141) || 挂载数据: 无 ) 
│   │   │   ├── 使用命令行界面（CLI） --> ( 难度等级: [0.0141, 0.0143) || 挂载数据: 无 ) 
│   │   │   │   └── 调用命令 --> ( 难度等级: [0.0141, 0.0143) || 挂载数据: 无 ) 
│   │   │   ├── Lambda模式 --> ( 难度等级: [0.0143, 0.0145) || 挂载数据: 无 ) 
│   │   │   │   ├── 异步瀑布 --> ( 难度等级: [0.0143, 0.0143) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列与并行 --> ( 难度等级: [0.0143, 0.0144) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用库 --> ( 难度等级: [0.0144, 0.0145) || 挂载数据: 无 ) 
│   │   │   │   └── 把逻辑移到另一个文件中 --> ( 难度等级: [0.0145, 0.0145) || 挂载数据: 无 ) 
│   │   │   └── 测试Lambda函数 . --> ( 难度等级: [0.0145, 0.0147) || 挂载数据: 无 ) 
│   │   │       ├── 在本地测试 --> ( 难度等级: [0.0145, 0.0146) || 挂载数据: 无 ) 
│   │   │       └── 编写测试 --> ( 难度等级: [0.0146, 0.0147) || 挂载数据: 无 ) 
│   │   ├── 拓展架构 --> ( 难度等级: [0.0147, 0.0159) || 挂载数据: 无 ) 
│   │   ├── 存储 . --> ( 难度等级: [0.0159, 0.0172) || 挂载数据: 无 ) 
│   │   │   ├── 更智能的存储 --> ( 难度等级: [0.0159, 0.0163) || 挂载数据: 无 ) 
│   │   │   │   ├── 版本控制 --> ( 难度等级: [0.0159, 0.016) || 挂载数据: 无 ) 
│   │   │   │   ├── 托管静态网站 --> ( 难度等级: [0.016, 0.0161) || 挂载数据: 无 ) 
│   │   │   │   ├── 存储类别 --> ( 难度等级: [0.0161, 0.0161) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 对象生命周期管理 --> ( 难度等级: [0.0161, 0.0162) || 挂载数据: 无 ) 
│   │   │   │   ├── 转移加速 --> ( 难度等级: [0.0162, 0.0163) || 挂载数据: 无 ) 
│   │   │   │   └── 事件通知 --> ( 难度等级: [0.0163, 0.0163) || 挂载数据: 无 ) 
│   │   │   ├── 安全上传 --> ( 难度等级: [0.0163, 0.0167) || 挂载数据: 无 ) 
│   │   │   │   ├── 上传策略Lambda --> ( 难度等级: [0.0163, 0.0165) || 挂载数据: 无 ) 
│   │   │   │   ├── S3 CORS配置 --> ( 难度等级: [0.0165, 0.0166) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 在网站中上传 --> ( 难度等级: [0.0166, 0.0167) || 挂载数据: blog: 1 ) 
│   │   │   └── 限制对文件的访问 --> ( 难度等级: [0.0167, 0.0172) || 挂载数据: 无 ) 
│   │   │       ├── 禁止公开访问 --> ( 难度等级: [0.0167, 0.0168) || 挂载数据: 无 ) 
│   │   │       ├── 生成预签名URL --> ( 难度等级: [0.0168, 0.0169) || 挂载数据: blog: 1 ) 
│   │   │       ├── 签名URL Lambda --> ( 难度等级: [0.0169, 0.017) || 挂载数据: blog: 1 ) 
│   │   │       ├── API Gateway设置 --> ( 难度等级: [0.017, 0.017) || 挂载数据: 无 ) 
│   │   │       ├── 提升性能 --> ( 难度等级: [0.017, 0.0171) || 挂载数据: 无 ) 
│   │   │       └── 提升Firebase安全性 --> ( 难度等级: [0.0171, 0.0172) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.0172, 0.0184) || 挂载数据: 无 ) 
│   │   │   ├── Firebase简介 --> ( 难度等级: [0.0172, 0.0178) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据结构 --> ( 难度等级: [0.0172, 0.0175) || 挂载数据: 无 ) 
│   │   │   │   └── 安全规则 --> ( 难度等级: [0.0175, 0.0178) || 挂载数据: 无 ) 
│   │   │   └── 为 24 小时视频添加Firebase --> ( 难度等级: [0.0178, 0.0184) || 挂载数据: 无 ) 
│   │   │       ├── 设置Firebase --> ( 难度等级: [0.0178, 0.0179) || 挂载数据: 无 ) 
│   │   │       ├── 修改转码视频Lambda --> ( 难度等级: [0.0179, 0.018) || 挂载数据: 无 ) 
│   │   │       ├── Transcode Video Firebase Update函数 --> ( 难度等级: [0.018, 0.0181) || 挂载数据: 无 ) 
│   │   │       ├── 连接Lambda --> ( 难度等级: [0.0181, 0.0182) || 挂载数据: 无 ) 
│   │   │       ├── 网站 --> ( 难度等级: [0.0182, 0.0183) || 挂载数据: blog: 1 ) 
│   │   │       └── 端到端测试 --> ( 难度等级: [0.0183, 0.0184) || 挂载数据: 无 ) 
│   │   ├── 最后一英里 . --> ( 难度等级: [0.0184, 0.0196) || 挂载数据: 无 ) 
│   │   │   ├── 部署与框架 --> ( 难度等级: [0.0184, 0.0186) || 挂载数据: 无 ) 
│   │   │   ├── 迈向更好的微服务 --> ( 难度等级: [0.0186, 0.0189) || 挂载数据: 无 ) 
│   │   │   ├── Step Functions --> ( 难度等级: [0.0189, 0.0191) || 挂载数据: 无 ) 
│   │   │   ├── AWS Marketplace --> ( 难度等级: [0.0191, 0.0194) || 挂载数据: 无 ) 
│   │   │   └── 未来之路 --> ( 难度等级: [0.0194, 0.0196) || 挂载数据: 无 ) 
│   │   ├── Serverless基础 --> ( 难度等级: [0.0196, 0.0208) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Serverless --> ( 难度等级: [0.0196, 0.0198) || 挂载数据: 无 ) 
│   │   │   │   ├── Serverless技术的发展 --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 9 ) 
│   │   │   │   ├── Serverless框架和工具 --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 6 ) 
│   │   │   │   │   ├── Chalice --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Claudia.js --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Apex --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Spring Cloud Function --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 10 ) 
│   │   │   │   │   └── AWS SAM --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Serverless后台服务 --> ( 难度等级: [0.0196, 0.0197) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 获取AWS账号 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── AWS Lambda控制面板 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 编辑函数 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试函数 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部访问 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 运维监控 --> ( 难度等级: [0.0197, 0.0198) || 挂载数据: 无 ) 
│   │   │   │   └── 回顾 --> ( 难度等级: [0.0198, 0.0198) || 挂载数据: blog: 1 ) 
│   │   │   ├── Serverless带来的价值 --> ( 难度等级: [0.0198, 0.02) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的技术实现 --> ( 难度等级: [0.02, 0.0201) || 挂载数据: 无 ) 
│   │   │   │   ├── 理念与实现 --> ( 难度等级: [0.02, 0.02) || 挂载数据: 无 ) 
│   │   │   │   └── FaaS与BaaS --> ( 难度等级: [0.02, 0.0201) || 挂载数据: 无 ) 
│   │   │   │       ├── FaaS的架构 --> ( 难度等级: [0.02, 0.0201) || 挂载数据: blog: 10 ) 
│   │   │   │       ├── 函数的生命周期 --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: 无 ) 
│   │   │   │       ├── 函数工作流 --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── BaaS的价值 --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: blog: 2 ) 
│   │   │   │       └── 广义的Serverless --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: 无 ) 
│   │   │   ├── Serverless应用架构 --> ( 难度等级: [0.0201, 0.0203) || 挂载数据: 无 ) 
│   │   │   │   ├── 传统应用架构 --> ( 难度等级: [0.0201, 0.0202) || 挂载数据: 无 ) 
│   │   │   │   └── Serverless应用架构 --> ( 难度等级: [0.0202, 0.0203) || 挂载数据: blog: 10 ) 
│   │   │   ├── Serverless的技术特点 --> ( 难度等级: [0.0203, 0.0205) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的应用场景 --> ( 难度等级: [0.0205, 0.0207) || 挂载数据: 无 ) 
│   │   │   └── Serverless的局限 --> ( 难度等级: [0.0207, 0.0208) || 挂载数据: 无 ) 
│   │   ├── AWS Lambda --> ( 难度等级: [0.0208, 0.0221) || 挂载数据: 无 ) 
│   │   │   ├── AWS Serverless --> ( 难度等级: [0.0208, 0.021) || 挂载数据: blog: 10 ) 
│   │   │   ├── AWS Lambda概述 --> ( 难度等级: [0.021, 0.0212) || 挂载数据: blog: 10 ) 
│   │   │   ├── 权限控制 --> ( 难度等级: [0.0212, 0.0214) || 挂载数据: 无 ) 
│   │   │   │   ├── IAM --> ( 难度等级: [0.0212, 0.0212) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 策略 --> ( 难度等级: [0.0212, 0.0213) || 挂载数据: 无 ) 
│   │   │   │   └── 角色 --> ( 难度等级: [0.0213, 0.0214) || 挂载数据: 无 ) 
│   │   │   ├── 事件驱动 --> ( 难度等级: [0.0214, 0.0215) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件源 --> ( 难度等级: [0.0214, 0.0214) || 挂载数据: 无 ) 
│   │   │   │   └── 触发模式 --> ( 难度等级: [0.0214, 0.0215) || 挂载数据: 无 ) 
│   │   │   ├── 日志监控 --> ( 难度等级: [0.0215, 0.0217) || 挂载数据: 无 ) 
│   │   │   ├── 开发辅助 --> ( 难度等级: [0.0217, 0.0219) || 挂载数据: 无 ) 
│   │   │   │   └── 标签 --> ( 难度等级: [0.0217, 0.0219) || 挂载数据: 无 ) 
│   │   │   └── 运行限制 --> ( 难度等级: [0.0219, 0.0221) || 挂载数据: 无 ) 
│   │   │       ├── 资源限制 --> ( 难度等级: [0.0219, 0.022) || 挂载数据: 无 ) 
│   │   │       └── 并发控制 --> ( 难度等级: [0.022, 0.0221) || 挂载数据: 无 ) 
│   │   ├── Azure Functions --> ( 难度等级: [0.0221, 0.0233) || 挂载数据: 无 ) 
│   │   │   ├── Microsoft Azure --> ( 难度等级: [0.0221, 0.0223) || 挂载数据: blog: 1 ) 
│   │   │   ├── Azure Functions概述 --> ( 难度等级: [0.0223, 0.0225) || 挂载数据: 无 ) 
│   │   │   ├── 创建Azure Serverless应用 --> ( 难度等级: [0.0225, 0.0227) || 挂载数据: 无 ) 
│   │   │   │   ├── 注册Azure账号 --> ( 难度等级: [0.0225, 0.0225) || 挂载数据: 无 ) 
│   │   │   │   ├── Azure控制台 --> ( 难度等级: [0.0225, 0.0226) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 调用函数 --> ( 难度等级: [0.0226, 0.0227) || 挂载数据: 无 ) 
│   │   │   ├── Azure Functions命令行 --> ( 难度等级: [0.0227, 0.0229) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装命令行 --> ( 难度等级: [0.0227, 0.0228) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 发布至公有云 --> ( 难度等级: [0.0228, 0.0229) || 挂载数据: 无 ) 
│   │   │   ├── 深入了解Azure Functions --> ( 难度等级: [0.0229, 0.0231) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数应用设置 --> ( 难度等级: [0.0229, 0.0229) || 挂载数据: 无 ) 
│   │   │   │   ├── Trigger与Bindings --> ( 难度等级: [0.0229, 0.023) || 挂载数据: 无 ) 
│   │   │   │   │   ├── HTTP Trigger --> ( 难度等级: [0.0229, 0.0229) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Cronjob Trigger --> ( 难度等级: [0.0229, 0.023) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Kafka Trigger --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │   │   │   └── NATS Trigger --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数代理 --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │   │   └── Slot --> ( 难度等级: [0.023, 0.0231) || 挂载数据: 无 ) 
│   │   │   └── 私有云部署 --> ( 难度等级: [0.0231, 0.0233) || 挂载数据: 无 ) 
│   │   ├── 容器技术基础 --> ( 难度等级: [0.0233, 0.0245) || 挂载数据: 无 ) 
│   │   │   ├── 什么是容器 --> ( 难度等级: [0.0233, 0.0236) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器 --> ( 难度等级: [0.0233, 0.0234) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 容器镜像 --> ( 难度等级: [0.0234, 0.0234) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 镜像仓库 --> ( 难度等级: [0.0234, 0.0235) || 挂载数据: 无 ) 
│   │   │   │   └── 容器编排 --> ( 难度等级: [0.0235, 0.0236) || 挂载数据: 无 ) 
│   │   │   ├── Docker --> ( 难度等级: [0.0236, 0.0239) || 挂载数据: 无 ) 
│   │   │   │   ├── Vagrant --> ( 难度等级: [0.0236, 0.0236) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── VirtualBox --> ( 难度等级: [0.0236, 0.0237) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 安装Docker --> ( 难度等级: [0.0237, 0.0237) || 挂载数据: 无 ) 
│   │   │   │   ├── 运行容器 --> ( 难度等级: [0.0237, 0.0238) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建容器镜像 --> ( 难度等级: [0.0238, 0.0238) || 挂载数据: 无 ) 
│   │   │   │   └── 分享镜像 --> ( 难度等级: [0.0238, 0.0239) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes基础 --> ( 难度等级: [0.0239, 0.0242) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名空间 --> ( 难度等级: [0.0239, 0.0239) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod --> ( 难度等级: [0.0239, 0.024) || 挂载数据: 无 ) 
│   │   │   │   ├── Service --> ( 难度等级: [0.024, 0.024) || 挂载数据: 无 ) 
│   │   │   │   ├── Deployment --> ( 难度等级: [0.024, 0.0241) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet --> ( 难度等级: [0.0241, 0.0241) || 挂载数据: 无 ) 
│   │   │   │   ├── 网络 --> ( 难度等级: [0.0241, 0.0241) || 挂载数据: 无 ) 
│   │   │   │   ├── Ingress --> ( 难度等级: [0.0241, 0.0242) || 挂载数据: 无 ) 
│   │   │   │   └── 交互工具 --> ( 难度等级: [0.0242, 0.0242) || 挂载数据: 无 ) 
│   │   │   └── 构建Kubernetes环境 --> ( 难度等级: [0.0242, 0.0245) || 挂载数据: 无 ) 
│   │   │       ├── 启动Vagrant Box --> ( 难度等级: [0.0242, 0.0244) || 挂载数据: 无 ) 
│   │   │       └── 修改默认域 --> ( 难度等级: [0.0244, 0.0245) || 挂载数据: 无 ) 
│   │   ├── Serverless的落地与展望 --> ( 难度等级: [0.0245, 0.0257) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的落地 --> ( 难度等级: [0.0245, 0.0248) || 挂载数据: 无 ) 
│   │   │   ├── Serverless平台建设 --> ( 难度等级: [0.0248, 0.0251) || 挂载数据: 无 ) 
│   │   │   │   ├── 公有云 --> ( 难度等级: [0.0248, 0.0249) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 私有云 --> ( 难度等级: [0.0249, 0.025) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 混合云 --> ( 难度等级: [0.025, 0.0251) || 挂载数据: 无 ) 
│   │   │   ├── Serverless应用架构转型 --> ( 难度等级: [0.0251, 0.0254) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发模式 --> ( 难度等级: [0.0251, 0.0252) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计原则 --> ( 难度等级: [0.0252, 0.0253) || 挂载数据: 无 ) 
│   │   │   │   └── 迁移与重构 --> ( 难度等级: [0.0253, 0.0254) || 挂载数据: 无 ) 
│   │   │   └── Serverless的未来 --> ( 难度等级: [0.0254, 0.0257) || 挂载数据: 无 ) 
│   │   │       ├── 建立行业规范 --> ( 难度等级: [0.0254, 0.0256) || 挂载数据: 无 ) 
│   │   │       └── 完善工具链 --> ( 难度等级: [0.0256, 0.0257) || 挂载数据: 无 ) 
│   │   ├── 初识Serverless --> ( 难度等级: [0.0257, 0.027) || 挂载数据: 无 ) 
│   │   │   ├── 优势与劣势 --> ( 难度等级: [0.0257, 0.0261) || 挂载数据: 无 ) 
│   │   │   ├── 影响力和价值 --> ( 难度等级: [0.0261, 0.0266) || 挂载数据: 无 ) 
│   │   │   └── 典型应用场景 --> ( 难度等级: [0.0266, 0.027) || 挂载数据: 无 ) 
│   │   │       ├── 视频转码服务 --> ( 难度等级: [0.0266, 0.0266) || 挂载数据: 无 ) 
│   │   │       ├── 数据ETL处理服务 --> ( 难度等级: [0.0266, 0.0267) || 挂载数据: 无 ) 
│   │   │       ├── 网站（服务）后端 --> ( 难度等级: [0.0267, 0.0268) || 挂载数据: 无 ) 
│   │   │       ├── 人工智能推理预测 --> ( 难度等级: [0.0268, 0.0269) || 挂载数据: 无 ) 
│   │   │       └── 物联网相关应用 --> ( 难度等级: [0.0269, 0.027) || 挂载数据: 无 ) 
│   │   ├── Serverless入门 --> ( 难度等级: [0.027, 0.0282) || 挂载数据: 无 ) 
│   │   │   ├── Serverless架构规范 --> ( 难度等级: [0.027, 0.0273) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数相关规范 --> ( 难度等级: [0.027, 0.0271) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数生命周期 --> ( 难度等级: [0.0271, 0.0272) || 挂载数据: 无 ) 
│   │   │   │   └── 工作流程 --> ( 难度等级: [0.0272, 0.0273) || 挂载数据: 无 ) 
│   │   │   ├── 事件与规范 --> ( 难度等级: [0.0273, 0.0276) || 挂载数据: 无 ) 
│   │   │   │   ├── 相关术语 --> ( 难度等级: [0.0273, 0.0274) || 挂载数据: 无 ) 
│   │   │   │   └── 上下文属性 --> ( 难度等级: [0.0274, 0.0276) || 挂载数据: 无 ) 
│   │   │   ├── 工业化产品 --> ( 难度等级: [0.0276, 0.0279) || 挂载数据: 无 ) 
│   │   │   │   ├── Google Cloud Function --> ( 难度等级: [0.0276, 0.0277) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 腾讯云SCF --> ( 难度等级: [0.0277, 0.0279) || 挂载数据: blog: 3 ) 
│   │   │   └── 开发运维工具 --> ( 难度等级: [0.0279, 0.0282) || 挂载数据: 无 ) 
│   │   │       ├── CLI命令行工具 --> ( 难度等级: [0.0279, 0.028) || 挂载数据: blog: 1 ) 
│   │   │       └── 插件 --> ( 难度等级: [0.028, 0.0282) || 挂载数据: 无 ) 
│   │   ├── Web与监控告警场景实践 --> ( 难度等级: [0.0282, 0.0294) || 挂载数据: 无 ) 
│   │   │   └── Web后端与应用服务端 --> ( 难度等级: [0.0282, 0.0294) || 挂载数据: 无 ) 
│   │   │       ├── 上传图片加水印 --> ( 难度等级: [0.0282, 0.0286) || 挂载数据: 无 ) 
│   │   │       ├── 用IP地址查天气并在小程序中应用 --> ( 难度等级: [0.0286, 0.029) || 挂载数据: 无 ) 
│   │   │       └── 简易用户反馈功能与快应用实践 --> ( 难度等级: [0.029, 0.0294) || 挂载数据: 无 ) 
│   │   ├── 大数据与人工智能场景实践 --> ( 难度等级: [0.0294, 0.0306) || 挂载数据: 无 ) 
│   │   │   ├── 大数据技术之MapReduce的简单实现 --> ( 难度等级: [0.0294, 0.03) || 挂载数据: blog: 5 ) 
│   │   │   └── 人工智能领域的实践 --> ( 难度等级: [0.03, 0.0306) || 挂载数据: blog: 1 ) 
│   │   │       ├── 自然语言处理为你的网站赋能 --> ( 难度等级: [0.03, 0.0302) || 挂载数据: 无 ) 
│   │   │       ├── 智能客服与微信小程序 --> ( 难度等级: [0.0302, 0.0303) || 挂载数据: blog: 2 ) 
│   │   │       ├── 简单的车牌识别系统 --> ( 难度等级: [0.0303, 0.0305) || 挂载数据: 无 ) 
│   │   │       └── 视觉：对象检测系统 --> ( 难度等级: [0.0305, 0.0306) || 挂载数据: blog: 1 ) 
│   │   ├── 物联网和其他场景实践 --> ( 难度等级: [0.0306, 0.0319) || 挂载数据: 无 ) 
│   │   │   ├── 物联网相关—定制智能音箱小工具 --> ( 难度等级: [0.0306, 0.0312) || 挂载数据: blog: 1 ) 
│   │   │   └── 其他场景实践 --> ( 难度等级: [0.0312, 0.0319) || 挂载数据: 无 ) 
│   │   │       ├── OJ判题机/小程序在线编程系统实现 --> ( 难度等级: [0.0312, 0.0316) || 挂载数据: blog: 1 ) 
│   │   │       └── 微信公众号机器人 --> ( 难度等级: [0.0316, 0.0319) || 挂载数据: 无 ) 
│   │   ├── Serverless范式 --> ( 难度等级: [0.0319, 0.0331) || 挂载数据: 无 ) 
│   │   │   ├── Serverless架构不仅仅是实时的 --> ( 难度等级: [0.0319, 0.0325) || 挂载数据: 无 ) 
│   │   │   └── Serverless的优缺点 --> ( 难度等级: [0.0325, 0.0331) || 挂载数据: 无 ) 
│   │   ├── 在AWS中构建Serverless应用程序 --> ( 难度等级: [0.0331, 0.0343) || 挂载数据: 无 ) 
│   │   │   ├── AWS Lambda的触发器 --> ( 难度等级: [0.0331, 0.0333) || 挂载数据: 无 ) 
│   │   │   ├── 函数即容器 --> ( 难度等级: [0.0333, 0.0336) || 挂载数据: 无 ) 
│   │   │   ├── 配置函数 --> ( 难度等级: [0.0336, 0.0338) || 挂载数据: 无 ) 
│   │   │   ├── Lambda函数的版本控制 --> ( 难度等级: [0.0338, 0.0341) || 挂载数据: 无 ) 
│   │   │   └── 创建部署包 --> ( 难度等级: [0.0341, 0.0343) || 挂载数据: 无 ) 
│   │   ├── 设置Serverless架构 --> ( 难度等级: [0.0343, 0.0355) || 挂载数据: 无 ) 
│   │   │   ├── S3触发器 --> ( 难度等级: [0.0343, 0.0346) || 挂载数据: 无 ) 
│   │   │   ├── SNS触发器 --> ( 难度等级: [0.0346, 0.0349) || 挂载数据: 无 ) 
│   │   │   ├── SQS触发器 --> ( 难度等级: [0.0349, 0.0352) || 挂载数据: 无 ) 
│   │   │   └── CloudWatch触发器 --> ( 难度等级: [0.0352, 0.0355) || 挂载数据: 无 ) 
│   │   ├── 部署Serverless API --> ( 难度等级: [0.0355, 0.0368) || 挂载数据: 无 ) 
│   │   │   ├── 设置集成 --> ( 难度等级: [0.0355, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── 为API部署Lambda函数 --> ( 难度等级: [0.0359, 0.0364) || 挂载数据: 无 ) 
│   │   │   └── 处理身份验证与用户控制 --> ( 难度等级: [0.0364, 0.0368) || 挂载数据: 无 ) 
│   │   ├── 扩展Serverless架构 --> ( 难度等级: [0.0368, 0.038) || 挂载数据: 无 ) 
│   │   │   ├── 第三方编排工具 --> ( 难度等级: [0.0368, 0.0372) || 挂载数据: 无 ) 
│   │   │   ├── 服务器的创建和终止 --> ( 难度等级: [0.0372, 0.0376) || 挂载数据: 无 ) 
│   │   │   └── 扩展的难点及解决方案 --> ( 难度等级: [0.0376, 0.038) || 挂载数据: 无 ) 
│   │   ├── AWS Lambda的安全性 --> ( 难度等级: [0.038, 0.0392) || 挂载数据: 无 ) 
│   │   │   ├── 了解AWS VPC --> ( 难度等级: [0.038, 0.0382) || 挂载数据: blog: 6 ) 
│   │   │   ├── 了解VPC中的子网 --> ( 难度等级: [0.0382, 0.0385) || 挂载数据: 无 ) 
│   │   │   ├── 在私有子网内保护Lambda --> ( 难度等级: [0.0385, 0.0387) || 挂载数据: 无 ) 
│   │   │   ├── Lambda函数的访问控制 --> ( 难度等级: [0.0387, 0.039) || 挂载数据: 无 ) 
│   │   │   └── 在Lambda中使用STS执行安全会话 --> ( 难度等级: [0.039, 0.0392) || 挂载数据: 无 ) 
│   │   ├── 使用SAM部署Lambda函数 --> ( 难度等级: [0.0392, 0.0404) || 挂载数据: 无 ) 
│   │   │   ├── SAM简介 --> ( 难度等级: [0.0392, 0.0395) || 挂载数据: 无 ) 
│   │   │   ├── 将CloudFormation用于Serverless服务 --> ( 难度等级: [0.0395, 0.0398) || 挂载数据: 无 ) 
│   │   │   ├── 使用SAM进行部署 --> ( 难度等级: [0.0398, 0.0401) || 挂载数据: 无 ) 
│   │   │   └── 了解SAM中的安全性 --> ( 难度等级: [0.0401, 0.0404) || 挂载数据: 无 ) 
│   │   └── 微软Azure Functions简介 --> ( 难度等级: [0.0404, 0.0417) || 挂载数据: 无 ) 
│   │       ├── 微软Azure Functions简介 --> ( 难度等级: [0.0404, 0.0407) || 挂载数据: 无 ) 
│   │       ├── 创建你的第一个Azure Function --> ( 难度等级: [0.0407, 0.0411) || 挂载数据: 无 ) 
│   │       ├── 了解触发器 --> ( 难度等级: [0.0411, 0.0414) || 挂载数据: 无 ) 
│   │       └── 编写微软Azure Functions的最佳实践 --> ( 难度等级: [0.0414, 0.0417) || 挂载数据: 无 ) 
│   ├── 微服务 --> ( 难度等级: [0.0417, 0.0833) || 挂载数据: 无 ) 
│   │   ├── Service Mesh --> ( 难度等级: [0.0417, 0.0423) || 挂载数据: 无 ) 
│   │   │   ├── Istio --> ( 难度等级: [0.0417, 0.0418) || 挂载数据: 无 ) 
│   │   │   ├── Linkerd --> ( 难度等级: [0.0418, 0.0419) || 挂载数据: 无 ) 
│   │   │   ├── Conduit --> ( 难度等级: [0.0419, 0.042) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh的现状 --> ( 难度等级: [0.042, 0.0421) || 挂载数据: 无 ) 
│   │   │   └── Istio架构分析 --> ( 难度等级: [0.0421, 0.0423) || 挂载数据: 无 ) 
│   │   ├── Framework --> ( 难度等级: [0.0423, 0.0429) || 挂载数据: blog: 2 ) 
│   │   │   ├── Dubbo --> ( 难度等级: [0.0423, 0.0425) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud --> ( 难度等级: [0.0425, 0.0427) || 挂载数据: 无 ) 
│   │   │   │   ├── 简介 --> ( 难度等级: [0.0425, 0.0426) || 挂载数据: 无 ) 
│   │   │   │   └── 常用组件 --> ( 难度等级: [0.0426, 0.0427) || 挂载数据: 无 ) 
│   │   │   └── Tars --> ( 难度等级: [0.0427, 0.0429) || 挂载数据: 无 ) 
│   │   ├── 微服务简介 --> ( 难度等级: [0.0429, 0.0435) || 挂载数据: 无 ) 
│   │   │   ├── 单体架构及其存在的不足 --> ( 难度等级: [0.0429, 0.043) || 挂载数据: 无 ) 
│   │   │   │   ├── 单体架构简介 --> ( 难度等级: [0.0429, 0.0429) || 挂载数据: 无 ) 
│   │   │   │   ├── 单体架构存在的不足 --> ( 难度等级: [0.0429, 0.043) || 挂载数据: 无 ) 
│   │   │   │   └── 单体架构使用服务器集群及存在的不足 --> ( 难度等级: [0.043, 0.043) || 挂载数据: blog: 2 ) 
│   │   │   ├── 微服务 --> ( 难度等级: [0.043, 0.0431) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是微服务 --> ( 难度等级: [0.043, 0.0431) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 微服务的优势 --> ( 难度等级: [0.0431, 0.0431) || 挂载数据: 无 ) 
│   │   │   ├── 微服务的不足 --> ( 难度等级: [0.0431, 0.0432) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务的复杂度 --> ( 难度等级: [0.0431, 0.0431) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式事务 --> ( 难度等级: [0.0431, 0.0432) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 服务的划分 --> ( 难度等级: [0.0432, 0.0432) || 挂载数据: 无 ) 
│   │   │   │   └── 服务的部署 --> ( 难度等级: [0.0432, 0.0432) || 挂载数据: 无 ) 
│   │   │   ├── 微服务和SOA的关系 --> ( 难度等级: [0.0432, 0.0434) || 挂载数据: blog: 1 ) 
│   │   │   └── 微服务的设计原则 --> ( 难度等级: [0.0434, 0.0435) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud简介 --> ( 难度等级: [0.0435, 0.0441) || 挂载数据: 无 ) 
│   │   │   ├── 微服务应该具备的功能 --> ( 难度等级: [0.0435, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务的注册与发现 --> ( 难度等级: [0.0435, 0.0435) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 服务的负载均衡 --> ( 难度等级: [0.0435, 0.0435) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 服务的容错 --> ( 难度等级: [0.0435, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务网关 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务网关的实现原理 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── After路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Header断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Cookie路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Host路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   ├── Method路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Path路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── Query路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 过滤器 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 过滤器的作用 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 过滤器的生命周期 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 网关过滤器 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 全局过滤器 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 限流 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 常见的限流算法 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 服务网关的限流 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 普通方式 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 条件方式 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   └── 服务化 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 工程介绍 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │       └── service-gateway工程详细介绍 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务配置的统一管理 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   └── 服务链路追踪 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   ├── Dubbo简介 --> ( 难度等级: [0.0436, 0.0438) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes简介 --> ( 难度等级: [0.0438, 0.0439) || 挂载数据: 无 ) 
│   │   │   └── Spring Could与Kubernetes比较 --> ( 难度等级: [0.0439, 0.0441) || 挂载数据: 无 ) 
│   │   ├── 构建微服务的准备 --> ( 难度等级: [0.0441, 0.0447) || 挂载数据: 无 ) 
│   │   │   ├── JDK的安装 --> ( 难度等级: [0.0441, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── JDK的下载和安装 --> ( 难度等级: [0.0441, 0.0442) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 环境变量的配置 --> ( 难度等级: [0.0442, 0.0443) || 挂载数据: 无 ) 
│   │   │   ├── IDEA的安装 --> ( 难度等级: [0.0443, 0.0445) || 挂载数据: 无 ) 
│   │   │   │   ├── IDEA的下载 --> ( 难度等级: [0.0443, 0.0444) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 用IDEA创建一个Spring Boot工程 --> ( 难度等级: [0.0444, 0.0445) || 挂载数据: blog: 2 ) 
│   │   │   └── 构建工具Maven的使用 --> ( 难度等级: [0.0445, 0.0447) || 挂载数据: 无 ) 
│   │   │       ├── Maven简介 --> ( 难度等级: [0.0445, 0.0445) || 挂载数据: 无 ) 
│   │   │       ├── Maven的安装 --> ( 难度等级: [0.0445, 0.0446) || 挂载数据: blog: 2 ) 
│   │   │       ├── Maven的核心概念 --> ( 难度等级: [0.0446, 0.0446) || 挂载数据: 无 ) 
│   │   │       ├── 编写Pom文件 --> ( 难度等级: [0.0446, 0.0446) || 挂载数据: 无 ) 
│   │   │       └── 常用的Maven命令 --> ( 难度等级: [0.0446, 0.0447) || 挂载数据: 无 ) 
│   │   ├── 开发框架Spring Boot --> ( 难度等级: [0.0447, 0.0453) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot简介 --> ( 难度等级: [0.0447, 0.0448) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Boot的特点 --> ( 难度等级: [0.0447, 0.0447) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Spring Boot的优点 --> ( 难度等级: [0.0447, 0.0448) || 挂载数据: blog: 1 ) 
│   │   │   ├── 用IDEA构建Spring Boot工程 --> ( 难度等级: [0.0448, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Spring Boot工程中构建Web程序 --> ( 难度等级: [0.0448, 0.0448) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Spring Boot的测试 --> ( 难度等级: [0.0448, 0.0449) || 挂载数据: blog: 10 ) 
│   │   │   ├── Spring Boot配置文件详解 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义属性 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 将配置文件的属性赋给实体类 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义配置文件 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   └── 多个环境的配置文件 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   ├── 运行状态监控Actuator --> ( 难度等级: [0.0449, 0.045) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看运行程序的健康状态 --> ( 难度等级: [0.0449, 0.045) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看运行程序的Bean --> ( 难度等级: [0.045, 0.045) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Actuator关闭应用程序 --> ( 难度等级: [0.045, 0.045) || 挂载数据: 无 ) 
│   │   │   │   └── 使用shell连接Actuator --> ( 难度等级: [0.045, 0.045) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot整合JPA --> ( 难度等级: [0.045, 0.0451) || 挂载数据: blog: 1 ) 
│   │   │   ├── Spring Boot整合Redis --> ( 难度等级: [0.0451, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── Redis简介 --> ( 难度等级: [0.0451, 0.0451) || 挂载数据: 无 ) 
│   │   │   │   ├── Redis的安装 --> ( 难度等级: [0.0451, 0.0452) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 在Spring Boot中使用Redis --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: blog: 10 ) 
│   │   │   └── Spring Boot整合Swagger2，搭建Restful API在线文档 --> ( 难度等级: [0.0452, 0.0453) || 挂载数据: 无 ) 
│   │   ├── 负载均衡Ribbon --> ( 难度等级: [0.0453, 0.0459) || 挂载数据: 无 ) 
│   │   │   ├── RestTemplate简介 --> ( 难度等级: [0.0453, 0.0454) || 挂载数据: blog: 1 ) 
│   │   │   ├── Ribbon简介 --> ( 难度等级: [0.0454, 0.0455) || 挂载数据: blog: 1 ) 
│   │   │   ├── 使用RestTemplate和Ribbon来消费服务 --> ( 难度等级: [0.0455, 0.0457) || 挂载数据: blog: 10 ) 
│   │   │   ├── LoadBalancerClient简介 --> ( 难度等级: [0.0457, 0.0458) || 挂载数据: 无 ) 
│   │   │   └── 源码解析Ribbon --> ( 难度等级: [0.0458, 0.0459) || 挂载数据: 无 ) 
│   │   ├── 声明式调用Feign --> ( 难度等级: [0.0459, 0.0465) || 挂载数据: 无 ) 
│   │   │   ├── 写一个Feign客户端 --> ( 难度等级: [0.0459, 0.046) || 挂载数据: 无 ) 
│   │   │   ├── FeignClient详解 --> ( 难度等级: [0.046, 0.0461) || 挂载数据: 无 ) 
│   │   │   ├── FeignClient的配置 --> ( 难度等级: [0.0461, 0.0462) || 挂载数据: 无 ) 
│   │   │   ├── 从源码的角度讲解Feign的工作原理 --> ( 难度等级: [0.0462, 0.0463) || 挂载数据: 无 ) 
│   │   │   ├── 在Feign中使用HttpClient和OkHttp --> ( 难度等级: [0.0463, 0.0464) || 挂载数据: 无 ) 
│   │   │   └── Feign是如何实现负载均衡的 --> ( 难度等级: [0.0464, 0.0465) || 挂载数据: blog: 8 ) 
│   │   ├── 熔断器Hystrix --> ( 难度等级: [0.0465, 0.0471) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix简介 --> ( 难度等级: [0.0465, 0.0466) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix的设计原则 --> ( 难度等级: [0.0466, 0.0467) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix的工作机制 --> ( 难度等级: [0.0467, 0.0468) || 挂载数据: 无 ) 
│   │   │   ├── 在Feign上使用熔断器 --> ( 难度等级: [0.0468, 0.0469) || 挂载数据: 无 ) 
│   │   │   ├── 使用Hystrix Dashboard监控熔断器的状态 --> ( 难度等级: [0.0469, 0.047) || 挂载数据: 无 ) 
│   │   │   │   ├── 在RestTemplate中使用Hystrix Dashboard --> ( 难度等级: [0.0469, 0.047) || 挂载数据: 无 ) 
│   │   │   │   └── 在Feign中使用Hystrix Dashboard --> ( 难度等级: [0.047, 0.047) || 挂载数据: blog: 10 ) 
│   │   │   └── 使用Turbine聚合监控 --> ( 难度等级: [0.047, 0.0471) || 挂载数据: 无 ) 
│   │   ├── 路由网关Spring Cloud Zuul --> ( 难度等级: [0.0471, 0.0477) || 挂载数据: 无 ) 
│   │   │   └── Zuul的工作原理 --> ( 难度等级: [0.0471, 0.0477) || 挂载数据: blog: 3 ) 
│   │   ├── 配置中心Spring Cloud Config --> ( 难度等级: [0.0477, 0.0483) || 挂载数据: 无 ) 
│   │   │   ├── Config Server从本地读取配置文件 --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Config Server --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 构建Config Client --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: blog: 8 ) 
│   │   │   ├── Config Server从远程Git仓库读取配置文件 --> ( 难度等级: [0.0478, 0.0479) || 挂载数据: blog: 4 ) 
│   │   │   ├── 构建高可用的Config Server --> ( 难度等级: [0.0479, 0.0481) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Eureka Server --> ( 难度等级: [0.0479, 0.048) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 改造Config Server --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   └── 改造Config Client --> ( 难度等级: [0.048, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spring Cloud Bus刷新配置 --> ( 难度等级: [0.0481, 0.0482) || 挂载数据: 无 ) 
│   │   │   └── 将配置存储在MySQL数据库中 --> ( 难度等级: [0.0482, 0.0483) || 挂载数据: 无 ) 
│   │   │       ├── 改造config-server工程 --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: 无 ) 
│   │   │       └── 初始化数据库 --> ( 难度等级: [0.0482, 0.0483) || 挂载数据: blog: 1 ) 
│   │   ├── 服务链路追踪Spring Cloud Sleuth --> ( 难度等级: [0.0483, 0.0489) || 挂载数据: 无 ) 
│   │   │   ├── 基本术语 --> ( 难度等级: [0.0483, 0.0484) || 挂载数据: 无 ) 
│   │   │   ├── 案例讲解 --> ( 难度等级: [0.0484, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动Zipkin Server --> ( 难度等级: [0.0484, 0.0484) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建服务提供者 --> ( 难度等级: [0.0484, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   └── 构建服务消费者 --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: 无 ) 
│   │   │   ├── 在链路数据中添加自定义数据 --> ( 难度等级: [0.0485, 0.0486) || 挂载数据: 无 ) 
│   │   │   ├── 使用RabbitMQ传输链路数据 --> ( 难度等级: [0.0486, 0.0487) || 挂载数据: 无 ) 
│   │   │   ├── 在MySQL数据库中存储链路数据 --> ( 难度等级: [0.0487, 0.0487) || 挂载数据: 无 ) 
│   │   │   ├── 在ElasticSearch中存储链路数据 --> ( 难度等级: [0.0487, 0.0488) || 挂载数据: 无 ) 
│   │   │   └── 用Kibana展示链路数据 --> ( 难度等级: [0.0488, 0.0489) || 挂载数据: 无 ) 
│   │   ├── 微服务监控Spring Boot Admin --> ( 难度等级: [0.0489, 0.0495) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spring Boot Admin监控Spring Boot应用程序 --> ( 难度等级: [0.0489, 0.0491) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Spring Boot Admin Server --> ( 难度等级: [0.0489, 0.049) || 挂载数据: 无 ) 
│   │   │   │   └── 创建Spring Boot Admin Client --> ( 难度等级: [0.049, 0.0491) || 挂载数据: blog: 10 ) 
│   │   │   ├── 使用Spring Boot Admin监控Spring Cloud微服务 --> ( 难度等级: [0.0491, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Admin Server --> ( 难度等级: [0.0491, 0.0492) || 挂载数据: 无 ) 
│   │   │   │   └── 构建Admin Client --> ( 难度等级: [0.0492, 0.0493) || 挂载数据: blog: 3 ) 
│   │   │   └── 在Spring Boot Admin中添加Security和Mail组件 --> ( 难度等级: [0.0493, 0.0495) || 挂载数据: 无 ) 
│   │   │       ├── Spring Boot Admin集成Security组件 --> ( 难度等级: [0.0493, 0.0494) || 挂载数据: 无 ) 
│   │   │       └── Spring Boot Admin集成Mail组件 --> ( 难度等级: [0.0494, 0.0495) || 挂载数据: blog: 1 ) 
│   │   ├── Spring Boot Security详解 --> ( 难度等级: [0.0495, 0.0501) || 挂载数据: 无 ) 
│   │   │   ├── Spring Security简介 --> ( 难度等级: [0.0495, 0.0497) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是Spring Security --> ( 难度等级: [0.0495, 0.0496) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Spring Security提供的安全模块 --> ( 难度等级: [0.0496, 0.0497) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot Security与Spring Security的关系 --> ( 难度等级: [0.0497, 0.0499) || 挂载数据: 无 ) 
│   │   │   └── Spring Boot Security案例详解 --> ( 难度等级: [0.0499, 0.0501) || 挂载数据: 无 ) 
│   │   │       ├── 构建Spring Boot Security工程 --> ( 难度等级: [0.0499, 0.05) || 挂载数据: blog: 10 ) 
│   │   │       ├── 配置Spring Security --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 10 ) 
│   │   │       ├── 编写相关界面 --> ( 难度等级: [0.05, 0.05) || 挂载数据: 无 ) 
│   │   │       ├── Spring Security方法级别上的保护 --> ( 难度等级: [0.05, 0.0501) || 挂载数据: 无 ) 
│   │   │       └── 从数据库中读取用户的认证信息 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Cloud OAuth2保护微服务系统 --> ( 难度等级: [0.0501, 0.0507) || 挂载数据: 无 ) 
│   │   │   ├── 什么是OAuth2 --> ( 难度等级: [0.0501, 0.0503) || 挂载数据: 无 ) 
│   │   │   ├── 如何使用Spring OAuth2 --> ( 难度等级: [0.0503, 0.0505) || 挂载数据: 无 ) 
│   │   │   │   ├── OAuth2 Provider --> ( 难度等级: [0.0503, 0.0504) || 挂载数据: 无 ) 
│   │   │   │   └── OAuth2 Client --> ( 难度等级: [0.0504, 0.0505) || 挂载数据: blog: 6 ) 
│   │   │   └── 案例分析 --> ( 难度等级: [0.0505, 0.0507) || 挂载数据: 无 ) 
│   │   │       ├── 编写Eureka Server --> ( 难度等级: [0.0505, 0.0506) || 挂载数据: blog: 10 ) 
│   │   │       ├── 编写Uaa授权服务 --> ( 难度等级: [0.0506, 0.0506) || 挂载数据: 无 ) 
│   │   │       ├── 编写service-hi资源服务 --> ( 难度等级: [0.0506, 0.0506) || 挂载数据: 无 ) 
│   │   │       ├── 案例架构设计 --> ( 难度等级: [0.0506, 0.0507) || 挂载数据: 无 ) 
│   │   │       ├── 编写主Maven工程 --> ( 难度等级: [0.0507, 0.0507) || 挂载数据: 无 ) 
│   │   │       └── 编写user-service资源服务 --> ( 难度等级: [0.0507, 0.0507) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Security OAuth2和JWT保护微服务系统 --> ( 难度等级: [0.0507, 0.0513) || 挂载数据: 无 ) 
│   │   │   └── JWT简介 --> ( 难度等级: [0.0507, 0.0513) || 挂载数据: 无 ) 
│   │   │       ├── 什么是JWT --> ( 难度等级: [0.0507, 0.0509) || 挂载数据: blog: 10 ) 
│   │   │       ├── JWT的结构 --> ( 难度等级: [0.0509, 0.051) || 挂载数据: 无 ) 
│   │   │       ├── JWT的应用场景 --> ( 难度等级: [0.051, 0.0512) || 挂载数据: blog: 2 ) 
│   │   │       └── 如何使用JWT --> ( 难度等级: [0.0512, 0.0513) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Cloud构建微服务综合案例 --> ( 难度等级: [0.0513, 0.0519) || 挂载数据: 无 ) 
│   │   │   ├── 案例介绍 --> ( 难度等级: [0.0513, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   ├── 工程结构 --> ( 难度等级: [0.0513, 0.0514) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用的技术栈 --> ( 难度等级: [0.0514, 0.0514) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 工程架构 --> ( 难度等级: [0.0514, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   └── 功能展示 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   ├── 案例详解 --> ( 难度等级: [0.0515, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 准备工作 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建主Maven工程 --> ( 难度等级: [0.0515, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建eureka-server工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 构建config-server工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Zipkin工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建monitoring-service工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建uaa-service工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建gateway-service工程 --> ( 难度等级: [0.0516, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建admin-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建user-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建blog-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   └── 构建log-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   └── 启动源码工程 --> ( 难度等级: [0.0517, 0.0519) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud生态 --> ( 难度等级: [0.0519, 0.0525) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud基础：Spring Boot概述 --> ( 难度等级: [0.0519, 0.0521) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot核心特性 --> ( 难度等级: [0.0521, 0.0523) || 挂载数据: 无 ) 
│   │   │   │   ├── Web服务器：WebServer --> ( 难度等级: [0.0521, 0.0522) || 挂载数据: 无 ) 
│   │   │   │   ├── 条件注解：@ConditionalOnXX --> ( 难度等级: [0.0522, 0.0522) || 挂载数据: 无 ) 
│   │   │   │   ├── 工厂加载机制 --> ( 难度等级: [0.0522, 0.0523) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置加载机制 --> ( 难度等级: [0.0523, 0.0523) || 挂载数据: 无 ) 
│   │   │   │   └── Spring Boot Actuator --> ( 难度等级: [0.0523, 0.0523) || 挂载数据: blog: 1 ) 
│   │   │   └── Spring Cloud概述 --> ( 难度等级: [0.0523, 0.0525) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud诞生背景 --> ( 难度等级: [0.0523, 0.0524) || 挂载数据: 无 ) 
│   │   │       ├── Netflix OSS --> ( 难度等级: [0.0524, 0.0524) || 挂载数据: blog: 10 ) 
│   │   │       ├── Spring Cloud版本 --> ( 难度等级: [0.0524, 0.0525) || 挂载数据: blog: 10 ) 
│   │   │       └── Spring Cloud最新动态 --> ( 难度等级: [0.0525, 0.0525) || 挂载数据: blog: 10 ) 
│   │   ├── 负载均衡与服务调用 --> ( 难度等级: [0.0525, 0.0531) || 挂载数据: 无 ) 
│   │   │   ├── 负载均衡原理 --> ( 难度等级: [0.0525, 0.0526) || 挂载数据: blog: 2 ) 
│   │   │   ├── Spring Cloud LoadBalancer负载均衡组件 --> ( 难度等级: [0.0526, 0.0527) || 挂载数据: blog: 1 ) 
│   │   │   ├── Netflix Ribbon负载均衡 --> ( 难度等级: [0.0527, 0.0528) || 挂载数据: 无 ) 
│   │   │   │   ├── RibbonLoadBalancerClient --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── RibbonServer和Server --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ServerIntrospector --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── ILoadBalancer --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── ServerList --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ServerListUpdater --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── ServerStats --> ( 难度等级: [0.0527, 0.0528) || 挂载数据: 无 ) 
│   │   │   │   └── Ribbon缓存时间 --> ( 难度等级: [0.0528, 0.0528) || 挂载数据: blog: 10 ) 
│   │   │   ├── Dubbo LoadBalance负载均衡 --> ( 难度等级: [0.0528, 0.0528) || 挂载数据: 无 ) 
│   │   │   ├── OpenFeign：声明式Rest客户端 --> ( 难度等级: [0.0528, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenFeign概述 --> ( 难度等级: [0.0528, 0.0529) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── OpenFeign对JAX-RS的支持 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   └── OpenFeign底层执行原理 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   ├── Dubbo Spring Cloud ：服务调用的新选择 --> ( 难度等级: [0.0529, 0.053) || 挂载数据: 无 ) 
│   │   │   ├── 再谈路由和负载均衡 --> ( 难度等级: [0.053, 0.0531) || 挂载数据: 无 ) 
│   │   │   └── 案例：应用流量控制 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: 无 ) 
│   │   │       ├── 流量控制应用的业务场景 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: blog: 1 ) 
│   │   │       └── 使用Netflix Ribbon完成应用灰度发布 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: 无 ) 
│   │   ├── 配置管理 --> ( 难度等级: [0.0531, 0.0537) || 挂载数据: 无 ) 
│   │   │   ├── 配置中心背景概述 --> ( 难度等级: [0.0531, 0.0533) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Config Server/Client --> ( 难度等级: [0.0533, 0.0535) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Config Server --> ( 难度等级: [0.0533, 0.0534) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Spring Cloud Config Client --> ( 难度等级: [0.0534, 0.0534) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Spring Cloud Config Client与Service Discovery整合 --> ( 难度等级: [0.0534, 0.0535) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Spring Cloud Config配置动态刷新 --> ( 难度等级: [0.0535, 0.0535) || 挂载数据: blog: 2 ) 
│   │   │   └── 再谈配置动态刷新 --> ( 难度等级: [0.0535, 0.0537) || 挂载数据: 无 ) 
│   │   ├── 熔断器 --> ( 难度等级: [0.0537, 0.0543) || 挂载数据: 无 ) 
│   │   │   ├── 熔断器模式概述 --> ( 难度等级: [0.0537, 0.0538) || 挂载数据: 无 ) 
│   │   │   ├── 手动实现一个断路器 --> ( 难度等级: [0.0538, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义State枚举和Counter计数器类 --> ( 难度等级: [0.0538, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义CircuitBreaker类 --> ( 难度等级: [0.0539, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   └── 使用CircuitBreaker进行场景测试 --> ( 难度等级: [0.0539, 0.0539) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Circuit Breaker的技术演进 --> ( 难度等级: [0.0539, 0.054) || 挂载数据: 无 ) 
│   │   │   ├── Alib*ba Sentinel --> ( 难度等级: [0.054, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── Sentinel核心概述 --> ( 难度等级: [0.054, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Alib*ba Sentinel --> ( 难度等级: [0.0541, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── Sentinel限流与Dashboard --> ( 难度等级: [0.0541, 0.0541) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Sentinel的高级特性 --> ( 难度等级: [0.0541, 0.0541) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Hystrix --> ( 难度等级: [0.0541, 0.0542) || 挂载数据: 无 ) 
│   │   │   │   ├── Hystrix核心概述 --> ( 难度等级: [0.0541, 0.0542) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Netflix Hystrix --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Hystrix限流与Dashboard --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │   │   └── Hystrix的高级特性 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │   └── Resilience4j --> ( 难度等级: [0.0542, 0.0543) || 挂载数据: 无 ) 
│   │   │       ├── Resilience4j体验 --> ( 难度等级: [0.0542, 0.0543) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Resilience4j --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │       └── Resilience4j的高级特性 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   ├── Spring生态消息驱动 --> ( 难度等级: [0.0543, 0.055) || 挂载数据: 无 ) 
│   │   │   ├── 消息中间件概述 --> ( 难度等级: [0.0543, 0.0545) || 挂载数据: 无 ) 
│   │   │   ├── Spring与消息 --> ( 难度等级: [0.0545, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息编程模型的统一 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息的发送和订阅 --> ( 难度等级: [0.0545, 0.0546) || 挂载数据: blog: 1 ) 
│   │   │   │   └── WebSocket --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Integration --> ( 难度等级: [0.0546, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Integration核心组件概述 --> ( 难度等级: [0.0546, 0.0547) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Spring Integration核心组件的使用 --> ( 难度等级: [0.0547, 0.0548) || 挂载数据: blog: 2 ) 
│   │   │   └── Spring Cloud Stream --> ( 难度等级: [0.0548, 0.055) || 挂载数据: 无 ) 
│   │   │       ├── 使用Spring Cloud Stream发送和接收消息 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: blog: 2 ) 
│   │   │       ├── 理解Binder和Binding --> ( 难度等级: [0.0548, 0.0549) || 挂载数据: 无 ) 
│   │   │       ├── 深入理解Spring Cloud Stream --> ( 难度等级: [0.0549, 0.0549) || 挂载数据: blog: 4 ) 
│   │   │       └── Spring Cloud Stream的高级特性 --> ( 难度等级: [0.0549, 0.055) || 挂载数据: blog: 1 ) 
│   │   ├── 消息总线 --> ( 难度等级: [0.055, 0.0556) || 挂载数据: 无 ) 
│   │   │   ├── 消息总线概述 --> ( 难度等级: [0.055, 0.0553) || 挂载数据: 无 ) 
│   │   │   └── 深入理解Spring Cloud Bus --> ( 难度等级: [0.0553, 0.0556) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus的使用 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus的原理 --> ( 难度等级: [0.0553, 0.0554) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus事件 --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │       └── Spring Cloud Bus源码分析 --> ( 难度等级: [0.0555, 0.0556) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud Data Flow --> ( 难度等级: [0.0556, 0.0562) || 挂载数据: 无 ) 
│   │   │   ├── 批处理/流处理概述 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   ├── 流处理案例：信用卡反欺诈系统 --> ( 难度等级: [0.0556, 0.0557) || 挂载数据: 无 ) 
│   │   │   ├── 批处理案例：统计GitHub仓库的各项指标数据 --> ( 难度等级: [0.0557, 0.0558) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Cloud Data Flow批处理任务组合 --> ( 难度等级: [0.0558, 0.0558) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Data Flow Shell --> ( 难度等级: [0.0558, 0.0559) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Cloud Skipper --> ( 难度等级: [0.0559, 0.056) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Deployer --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── TaskLauncher接口 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── AppDeployer接口 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   └── LocalAppDeployer --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Task --> ( 难度等级: [0.056, 0.0561) || 挂载数据: 无 ) 
│   │   │   │   ├── 体验Spring Cloud Task --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── 深入理解Spring Cloud Task --> ( 难度等级: [0.056, 0.0561) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Spring Cloud Task Batch --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   └── Spring Batch --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: 无 ) 
│   │   │       └── Spring Batch核心组件 --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: blog: 4 ) 
│   │   ├── 网关 --> ( 难度等级: [0.0562, 0.0568) || 挂载数据: 无 ) 
│   │   │   ├── API网关概述 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── API网关的定义、职能与关注点 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   └── API网关的分类与技术分析 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: blog: 6 ) 
│   │   │   ├── Netflix Zuul --> ( 难度等级: [0.0562, 0.0563) || 挂载数据: 无 ) 
│   │   │   ├── 非阻塞式的Spring Cloud Gateway --> ( 难度等级: [0.0563, 0.0564) || 挂载数据: 无 ) 
│   │   │   ├── Route路由信息 --> ( 难度等级: [0.0564, 0.0565) || 挂载数据: 无 ) 
│   │   │   ├── Predicate机制 --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   ├── PredicateDefinition和AsyncPredicate --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   ├── RoutePredicateFactory --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   └── 内置RoutePredicateFactory --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   ├── Filter机制 --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── FilterDefinition和GatewayFilter --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   ├── GlobalFilter --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   ├── 内置GatewayFilterFactory --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   └── 网关内置的GlobalFilter --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: blog: 1 ) 
│   │   │   ├── 整合注册中心和配置中心 --> ( 难度等级: [0.0566, 0.0567) || 挂载数据: 无 ) 
│   │   │   └── GatewayControllerEndpoint --> ( 难度等级: [0.0567, 0.0568) || 挂载数据: 无 ) 
│   │   ├── 综述 --> ( 难度等级: [0.0568, 0.0574) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的起源 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的组成 --> ( 难度等级: [0.0568, 0.0569) || 挂载数据: blog: 1 ) 
│   │   │   ├── Cloud Native背后的诉求 --> ( 难度等级: [0.0569, 0.057) || 挂载数据: 无 ) 
│   │   │   ├── 如何衡量Cloud Native的能力 --> ( 难度等级: [0.057, 0.0571) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的原则 --> ( 难度等级: [0.0571, 0.0571) || 挂载数据: 无 ) 
│   │   │   ├── 可用性和可靠性的关系 --> ( 难度等级: [0.0571, 0.0572) || 挂载数据: 无 ) 
│   │   │   ├── 可用性的衡量标准 --> ( 难度等级: [0.0572, 0.0573) || 挂载数据: 无 ) 
│   │   │   └── 什么降低了可用性 --> ( 难度等级: [0.0573, 0.0574) || 挂载数据: 无 ) 
│   │   ├── 微服务架构 --> ( 难度等级: [0.0574, 0.058) || 挂载数据: blog: 1 ) 
│   │   │   ├── 微服务架构的起源 --> ( 难度等级: [0.0574, 0.0574) || 挂载数据: 无 ) 
│   │   │   ├── 微服务架构实施的先决条件 --> ( 难度等级: [0.0574, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 研发环境和流程上的转变 --> ( 难度等级: [0.0574, 0.0574) || 挂载数据: 无 ) 
│   │   │   │   └── 拆分前先做好解耦 --> ( 难度等级: [0.0574, 0.0575) || 挂载数据: 无 ) 
│   │   │   ├── 微服务划分模式 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于业务复杂度选择服务划分方法 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于数据驱动划分服务 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 基于领域驱动划分服务 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 从已有单体架构中逐步划分服务 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务拆分策略 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 如何衡量服务划分的合理性 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   ├── 微服务划分反模式 --> ( 难度等级: [0.0575, 0.0576) || 挂载数据: 无 ) 
│   │   │   ├── 微服务API设计 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── YXAPI的设计原则 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务间通信——RPC --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列化——Protobuf --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务间通信——RESTful --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过Swagger实现RESTful --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── HTTP协议的进化——HTTP/2 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   └── HTTP/2和Protobuf的组合——gRPC --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   ├── 微服务框架 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   ├── 基于Dubbo框架实现微服务 --> ( 难度等级: [0.0576, 0.0577) || 挂载数据: 无 ) 
│   │   │   ├── 基于Spring Cloud框架实现微服务 --> ( 难度等级: [0.0577, 0.0577) || 挂载数据: 无 ) 
│   │   │   ├── 服务发现场景下的ZooKeeper与Etcd --> ( 难度等级: [0.0577, 0.0578) || 挂载数据: blog: 4 ) 
│   │   │   ├── 微服务部署策略 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务D享数据库 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   └── 服务D享虚拟机/容器 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   ├── 几种常见的微服务架构方案 --> ( 难度等级: [0.0578, 0.0579) || 挂载数据: 无 ) 
│   │   │   │   ├── ZeroC IceGrid微服务架构 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud微服务架构 --> ( 难度等级: [0.0578, 0.0579) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 基于消息队列的微服务架构 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │   │   └── Docker Swarm微服务架构 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: blog: 9 ) 
│   │   │   ├── 深入Kubernetes微服务平台 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Kubernetes的PaaS平台 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: blog: 1 ) 
│   │   │   └── 从微服务到Service Mesh --> ( 难度等级: [0.0579, 0.058) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service Mesh之再见架构 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │       ├── Envoy核心实践入门 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │       ├── Istio背后的技术 --> ( 难度等级: [0.0579, 0.058) || 挂载数据: blog: 1 ) 
│   │   │       └── Istio的架构演变 --> ( 难度等级: [0.058, 0.058) || 挂载数据: 无 ) 
│   │   ├── 敏捷基础设施及公共基础服务 --> ( 难度等级: [0.058, 0.0586) || 挂载数据: 无 ) 
│   │   │   ├── 传统基础设施面临的挑战 --> ( 难度等级: [0.058, 0.058) || 挂载数据: 无 ) 
│   │   │   ├── 什么是敏捷基础设施 --> ( 难度等级: [0.058, 0.0581) || 挂载数据: 无 ) 
│   │   │   ├── 基于容器的敏捷基础设施 --> ( 难度等级: [0.0581, 0.0582) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器VS虚拟机 --> ( 难度等级: [0.0581, 0.0581) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 安装Docker --> ( 难度等级: [0.0581, 0.0581) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署私有Docker Registry --> ( 难度等级: [0.0581, 0.0582) || 挂载数据: 无 ) 
│   │   │   │   └── 基于docker-compose管理容器 --> ( 难度等级: [0.0582, 0.0582) || 挂载数据: 无 ) 
│   │   │   ├── 基于公共基础服务的平台化 --> ( 难度等级: [0.0582, 0.0582) || 挂载数据: 无 ) 
│   │   │   ├── 监控告警fu务 --> ( 难度等级: [0.0582, 0.0583) || 挂载数据: 无 ) 
│   │   │   │   ├── 监控数据采集 --> ( 难度等级: [0.0582, 0.0583) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 监控数据接收模式 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过时间序列数据库存储监控数据 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: 无 ) 
│   │   │   │   ├── 开源监控系统实现Prometheus --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 通过Prometheus和Grafana监控服务 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: 无 ) 
│   │   │   ├── 分布式消息中间件服务 --> ( 难度等级: [0.0583, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式消息中间件的作用 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 业界常用的分布式消息中间件 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Kafka的设计原理 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Kafka的数据存储结构 --> ( 难度等级: [0.0583, 0.0584) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 如何保证Kafka不丢消息 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Kafka跨数据中心场景集群部署模式 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   ├── 分布式缓存服务 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式缓存的应用场景 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 业界常用的分布式缓存Memcached --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 业界常用的分布式缓存——Redis --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Redis常用的分布式缓存集群模式 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Codis实现Redis分布式缓存集群 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: blog: 3 ) 
│   │   │   ├── 分布式任务调度服务 --> ( 难度等级: [0.0584, 0.0585) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过Tbschedule实现分布式任务调度 --> ( 难度等级: [0.0584, 0.0585) || 挂载数据: 无 ) 
│   │   │   │   └── 通过Elastic-Job实现分布式任务调度 --> ( 难度等级: [0.0585, 0.0585) || 挂载数据: blog: 1 ) 
│   │   │   └── 如何生成分布式ID --> ( 难度等级: [0.0585, 0.0586) || 挂载数据: 无 ) 
│   │   │       ├── UUID --> ( 难度等级: [0.0585, 0.0585) || 挂载数据: 无 ) 
│   │   │       ├── SDwFlake --> ( 难度等级: [0.0585, 0.0586) || 挂载数据: 无 ) 
│   │   │       └── Ticket Server --> ( 难度等级: [0.0586, 0.0586) || 挂载数据: 无 ) 
│   │   ├── 可用性设计 --> ( 难度等级: [0.0586, 0.0592) || 挂载数据: 无 ) 
│   │   │   ├── 逐步切换 --> ( 难度等级: [0.0586, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 影子测试 --> ( 难度等级: [0.0586, 0.0586) || 挂载数据: 无 ) 
│   │   │   │   ├── 蓝绿部署 --> ( 难度等级: [0.0586, 0.0586) || 挂载数据: 无 ) 
│   │   │   │   └── 灰度发布/金丝雀发布 --> ( 难度等级: [0.0586, 0.0587) || 挂载数据: 无 ) 
│   │   │   ├── 容错设计 --> ( 难度等级: [0.0587, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   ├── 消除单点 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 特性开关 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务分级 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 降级设计 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 超时重试 --> ( 难度等级: [0.0587, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   └── 隔离策略 --> ( 难度等级: [0.0588, 0.0588) || 挂载数据: 无 ) 
│   │   │   ├── 流控设计 --> ( 难度等级: [0.0588, 0.0589) || 挂载数据: 无 ) 
│   │   │   │   ├── 限流算法 --> ( 难度等级: [0.0588, 0.0588) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 流控策略 --> ( 难度等级: [0.0588, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Guava限流 --> ( 难度等级: [0.0588, 0.0589) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Nginx限流 --> ( 难度等级: [0.0589, 0.0589) || 挂载数据: 无 ) 
│   │   │   ├── 容量预估 --> ( 难度等级: [0.0589, 0.059) || 挂载数据: 无 ) 
│   │   │   ├── 故障演练 --> ( 难度等级: [0.059, 0.0591) || 挂载数据: 无 ) 
│   │   │   └── 数据迁移 --> ( 难度等级: [0.0591, 0.0592) || 挂载数据: 无 ) 
│   │   │       ├── 逻辑分离，物理不分离 --> ( 难度等级: [0.0591, 0.0591) || 挂载数据: 无 ) 
│   │   │       └── 物理分离 --> ( 难度等级: [0.0591, 0.0592) || 挂载数据: 无 ) 
│   │   ├── 可扩展性设计 --> ( 难度等级: [0.0592, 0.0598) || 挂载数据: 无 ) 
│   │   │   ├── 横向扩展 --> ( 难度等级: [0.0592, 0.0593) || 挂载数据: 无 ) 
│   │   │   ├── AKF扩展立方体 --> ( 难度等级: [0.0593, 0.0594) || 挂载数据: 无 ) 
│   │   │   ├── 如何扩展长连接 --> ( 难度等级: [0.0594, 0.0595) || 挂载数据: 无 ) 
│   │   │   ├── 如何扩展数据库 --> ( 难度等级: [0.0595, 0.0597) || 挂载数据: 无 ) 
│   │   │   │   ├── X轴扩展——主从复制集群 --> ( 难度等级: [0.0595, 0.0596) || 挂载数据: 无 ) 
│   │   │   │   ├── Y轴扩展——分库、垂直分表 --> ( 难度等级: [0.0596, 0.0596) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Z轴扩展——分片（sharding） --> ( 难度等级: [0.0596, 0.0596) || 挂载数据: 无 ) 
│   │   │   │   ├── 分片扩容（re-sharding） --> ( 难度等级: [0.0596, 0.0596) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 精选案例 --> ( 难度等级: [0.0596, 0.0597) || 挂载数据: 无 ) 
│   │   │   └── 如何扩展数据中心 --> ( 难度等级: [0.0597, 0.0598) || 挂载数据: 无 ) 
│   │   │       ├── 两地三中心和同城多活 --> ( 难度等级: [0.0597, 0.0597) || 挂载数据: 无 ) 
│   │   │       ├── 同城多活 --> ( 难度等级: [0.0597, 0.0597) || 挂载数据: 无 ) 
│   │   │       └── 异地多活 --> ( 难度等级: [0.0597, 0.0598) || 挂载数据: 无 ) 
│   │   ├── 性能设计 --> ( 难度等级: [0.0598, 0.0604) || 挂载数据: 无 ) 
│   │   │   ├── 性能指标 --> ( 难度等级: [0.0598, 0.0598) || 挂载数据: 无 ) 
│   │   │   ├── 如何树立目标 --> ( 难度等级: [0.0598, 0.0599) || 挂载数据: 无 ) 
│   │   │   ├── 如何寻找平衡点 --> ( 难度等级: [0.0599, 0.06) || 挂载数据: 无 ) 
│   │   │   ├── 如何定位瓶颈点 --> ( 难度等级: [0.06, 0.0601) || 挂载数据: 无 ) 
│   │   │   ├── 服务通信优化 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   │   ├── 同步转异步 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   │   ├── 阻塞转非阻塞 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   │   └── 序列化 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   ├── 通过消息中间件提升写性能 --> ( 难度等级: [0.0601, 0.0602) || 挂载数据: blog: 1 ) 
│   │   │   ├── 通过缓存提升读性能 --> ( 难度等级: [0.0602, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于ConcurrentHashMap实现本地缓存 --> ( 难度等级: [0.0602, 0.0602) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 基于Guava Cache实现本地缓存 --> ( 难度等级: [0.0602, 0.0602) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 缓存的常用模式 --> ( 难度等级: [0.0602, 0.0603) || 挂载数据: 无 ) 
│   │   │   ├── 数据库优化 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过执行计划分析瓶颈点 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 为搜索字段创建索引 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过慢查询日志分析瓶颈点 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   └── 通过提升硬件能力优化数据库 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   └── 简化设计 --> ( 难度等级: [0.0603, 0.0604) || 挂载数据: 无 ) 
│   │   │       ├── 转移复杂度 --> ( 难度等级: [0.0603, 0.0604) || 挂载数据: 无 ) 
│   │   │       └── 从业务角度优化 --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: 无 ) 
│   │   ├── 一致性设计 --> ( 难度等级: [0.0604, 0.061) || 挂载数据: 无 ) 
│   │   │   ├── 基础理论 --> ( 难度等级: [0.0604, 0.0605) || 挂载数据: 无 ) 
│   │   │   │   ├── CAP定理 --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: 无 ) 
│   │   │   │   ├── BASE理论 --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Quorum机制（NWR模型） --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: 无 ) 
│   │   │   │   ├── 租约机制（Lease） --> ( 难度等级: [0.0604, 0.0605) || 挂载数据: 无 ) 
│   │   │   │   └── 状态机（Replicated State Machine） --> ( 难度等级: [0.0605, 0.0605) || 挂载数据: blog: 1 ) 
│   │   │   ├── 分布式系统的一致性分类 --> ( 难度等级: [0.0605, 0.0606) || 挂载数据: 无 ) 
│   │   │   │   ├── 以数据为中心的一致性模型 --> ( 难度等级: [0.0605, 0.0605) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 以用户为中心的一致性模型 --> ( 难度等级: [0.0605, 0.0606) || 挂载数据: 无 ) 
│   │   │   │   └── 业界常用的一致性模型 --> ( 难度等级: [0.0606, 0.0606) || 挂载数据: 无 ) 
│   │   │   ├── 如何实现强一致性 --> ( 难度等级: [0.0606, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── 两阶段提交 --> ( 难度等级: [0.0606, 0.0606) || 挂载数据: 无 ) 
│   │   │   │   └── 三阶段提交（3PC） --> ( 难度等级: [0.0606, 0.0607) || 挂载数据: blog: 1 ) 
│   │   │   ├── 如何实现Z终一致性 --> ( 难度等级: [0.0607, 0.0608) || 挂载数据: 无 ) 
│   │   │   │   ├── 重试机制 --> ( 难度等级: [0.0607, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地记录日志 --> ( 难度等级: [0.0607, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── 可靠事件模式 --> ( 难度等级: [0.0607, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── Saga事务模型 --> ( 难度等级: [0.0607, 0.0608) || 挂载数据: 无 ) 
│   │   │   │   └── TCC事务模型 --> ( 难度等级: [0.0608, 0.0608) || 挂载数据: 无 ) 
│   │   │   ├── 分布式锁 --> ( 难度等级: [0.0608, 0.0609) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于数据库实现悲观锁和乐观锁 --> ( 难度等级: [0.0608, 0.0608) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于ZooKeeper的分布式锁 --> ( 难度等级: [0.0608, 0.0609) || 挂载数据: blog: 7 ) 
│   │   │   │   └── 基于Redis实现分布式锁 --> ( 难度等级: [0.0609, 0.0609) || 挂载数据: blog: 10 ) 
│   │   │   └── 如何保证幂等性 --> ( 难度等级: [0.0609, 0.061) || 挂载数据: 无 ) 
│   │   │       ├── 幂等令牌（Idempotency Key） --> ( 难度等级: [0.0609, 0.0609) || 挂载数据: 无 ) 
│   │   │       └── 在数据库中实现幂等性 --> ( 难度等级: [0.0609, 0.061) || 挂载数据: 无 ) 
│   │   ├── 未来值得关注的方向 --> ( 难度等级: [0.061, 0.0616) || 挂载数据: blog: 1 ) 
│   │   │   └── Serverless --> ( 难度等级: [0.061, 0.0616) || 挂载数据: 无 ) 
│   │   │       ├── 什么是Serverless --> ( 难度等级: [0.061, 0.0612) || 挂载数据: 无 ) 
│   │   │       ├── Serverless的现状 --> ( 难度等级: [0.0612, 0.0614) || 挂载数据: 无 ) 
│   │   │       └── Serverless的应用场景 --> ( 难度等级: [0.0614, 0.0616) || 挂载数据: 无 ) 
│   │   ├── 研发流程 --> ( 难度等级: [0.0616, 0.0622) || 挂载数据: 无 ) 
│   │   │   ├── 十二因子 --> ( 难度等级: [0.0616, 0.0617) || 挂载数据: 无 ) 
│   │   │   ├── 自动化测试 --> ( 难度等级: [0.0617, 0.0618) || 挂载数据: 无 ) 
│   │   │   │   ├── 单元测试 --> ( 难度等级: [0.0617, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   ├── TDD --> ( 难度等级: [0.0617, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   └── 提交即意味着可测试 --> ( 难度等级: [0.0617, 0.0618) || 挂载数据: 无 ) 
│   │   │   ├── Code Review --> ( 难度等级: [0.0618, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── Code Review的意义 --> ( 难度等级: [0.0618, 0.0618) || 挂载数据: 无 ) 
│   │   │   │   ├── Code Review的原则 --> ( 难度等级: [0.0618, 0.0618) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Code Review的过程 --> ( 难度等级: [0.0618, 0.0619) || 挂载数据: 无 ) 
│   │   │   ├── 流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续交付 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续部署流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于开源打造流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── YMX的流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   └── 开发人员自服务 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   ├── 基于数据和反馈持续改进 --> ( 难度等级: [0.0619, 0.062) || 挂载数据: 无 ) 
│   │   │   ├── 拥抱变化 --> ( 难度等级: [0.062, 0.0621) || 挂载数据: 无 ) 
│   │   │   └── 代码即设计 --> ( 难度等级: [0.0621, 0.0622) || 挂载数据: 无 ) 
│   │   ├── 团队文化 --> ( 难度等级: [0.0622, 0.0628) || 挂载数据: 无 ) 
│   │   │   ├── 组织结构 --> ( 难度等级: [0.0622, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   ├── 康威定律 --> ( 难度等级: [0.0622, 0.0622) || 挂载数据: 无 ) 
│   │   │   │   ├── 扁平化的组织 --> ( 难度等级: [0.0622, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   ├── D裁的管理方式还是民主的管理方式 --> ( 难度等级: [0.0623, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   └── 民主的团队如何做决策 --> ( 难度等级: [0.0623, 0.0623) || 挂载数据: 无 ) 
│   │   │   ├── 环境氛围 --> ( 难度等级: [0.0623, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   ├── 公开透明的工作环境 --> ( 难度等级: [0.0623, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── 学习型组织 --> ( 难度等级: [0.0624, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── 减少正式的汇报 --> ( 难度等级: [0.0624, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── 高效的会议 --> ( 难度等级: [0.0624, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   └── 量化指标致死 --> ( 难度等级: [0.0625, 0.0625) || 挂载数据: 无 ) 
│   │   │   ├── 管理风格 --> ( 难度等级: [0.0625, 0.0627) || 挂载数据: 无 ) 
│   │   │   │   ├── 下属请假你会拒绝吗 --> ( 难度等级: [0.0625, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   ├── 得到了所有人的认可，说明你并不是一个好的管理者 --> ( 难度等级: [0.0625, 0.0626) || 挂载数据: 无 ) 
│   │   │   │   ├── 尽量避免用自己的权力去做决策 --> ( 难度等级: [0.0626, 0.0626) || 挂载数据: 无 ) 
│   │   │   │   ├── 一屋不扫也可助你“荡平天下” --> ( 难度等级: [0.0626, 0.0626) || 挂载数据: 无 ) 
│   │   │   │   └── 如何留下你想要的人 --> ( 难度等级: [0.0626, 0.0627) || 挂载数据: 无 ) 
│   │   │   └── 经典案例 --> ( 难度等级: [0.0627, 0.0628) || 挂载数据: 无 ) 
│   │   │       ├── Instagram的团队文化 --> ( 难度等级: [0.0627, 0.0627) || 挂载数据: 无 ) 
│   │   │       └── Netflix的团队文化 --> ( 难度等级: [0.0627, 0.0628) || 挂载数据: 无 ) 
│   │   ├── 基础篇 --> ( 难度等级: [0.0628, 0.0634) || 挂载数据: blog: 1 ) 
│   │   │   ├── Service Mesh简介 --> ( 难度等级: [0.0628, 0.0631) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务架构面临的一些挑战 --> ( 难度等级: [0.0628, 0.0629) || 挂载数据: 无 ) 
│   │   │   │   ├── 技术架构演进 --> ( 难度等级: [0.0629, 0.063) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Service Mesh的功能 --> ( 难度等级: [0.063, 0.063) || 挂载数据: 无 ) 
│   │   │   │   └── 业界Service Mesh产品 --> ( 难度等级: [0.063, 0.0631) || 挂载数据: 无 ) 
│   │   │   │       └── Envoy --> ( 难度等级: [0.063, 0.0631) || 挂载数据: blog: 1 ) 
│   │   │   └── Linkerd入门 --> ( 难度等级: [0.0631, 0.0634) || 挂载数据: 无 ) 
│   │   │       ├── Linkerd架构 --> ( 难度等级: [0.0631, 0.0632) || 挂载数据: 无 ) 
│   │   │       ├── Linkerd主要功能 --> ( 难度等级: [0.0632, 0.0633) || 挂载数据: 无 ) 
│   │   │       ├── 安装Linkerd --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   ├── 环境准备 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 虚拟机及Docker引擎 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 服务发现：Consul --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 10 ) 
│   │   │       │   │   ├── 部署Linkerd --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 部署示例服务 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 在本地搭建Istio环境 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 2 ) 
│   │   │       │   │   │   ├── 安装Kubernetes集群 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 1 ) 
│   │   │       │   │   │   ├── 安装Helm --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 1 ) 
│   │   │       │   │   │   └── 安装Istio --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 在公有云上使用Istio --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   └── 尝鲜Istio命令行 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   ├── 传统安装方式 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   └── 基于Docker的安装方式 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       └── 示例演示 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: 无 ) 
│   │   │           ├── 示例准备 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: blog: 1 ) 
│   │   │           │   ├── Weather Forecast简介 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │           │   └── Weather Forecast部署 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: 无 ) 
│   │   │           ├── 基于文件的服务发现 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: 无 ) 
│   │   │           └── 示例演示 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: 无 ) 
│   │   ├── 中级篇 --> ( 难度等级: [0.0634, 0.064) || 挂载数据: 无 ) 
│   │   │   ├── 深入浅出Linkerd配置 --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   ├── Linkerd术语 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: 无 ) 
│   │   │   │   └── Linkerd配置 --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置构成 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: blog: 10 ) 
│   │   │   │       ├── admin --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── namer --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── router --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── telemetry --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       └── usage --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   ├── 深入Linkerd数据访问流 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   ├── dtab详解 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   │   ├── dtab定义 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   │   └── dtab路由原理 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   └── 数据访问流详解 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 鉴别 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── 绑定 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── 解析 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 转换 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: 无 ) 
│   │   │   ├── Linkerd部署模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   ├── Linkerd部署模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Per-host模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Sidecar模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   │   └── Per-host模式和Sidecar模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   └── 配置模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │       ├── service-to-linker模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │       ├── linker-to-service模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │       └── linker-to-linker模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: blog: 6 ) 
│   │   │   ├── Linkerd控制层：Namerd --> ( 难度等级: [0.0636, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── Namerd简介 --> ( 难度等级: [0.0636, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── Namerd配置详解 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── admin配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── interface配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── storage配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   └── namer配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接Linkerd和Namerd --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Namerd配置文件 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动Namerd --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Linkerd配置文件 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   └── 启动Linkerd --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   └── 管理dtab路由 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │       ├── Namerd API简介 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │       ├── 通过Namerd API管理dtab --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │       └── 通过namerctl CLI管理dtab --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   ├── 东西向流量控制 --> ( 难度等级: [0.0637, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio东西向流量管理 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio路由控制 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现东西向流量转移路由 --> ( 难度等级: [0.0637, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   └── 实现流量镜像及对比分析 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   ├── 南北向流量控制 --> ( 难度等级: [0.0638, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio南北向流量管理 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio网关与K8s Ingress --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── 保护Istio网关流量 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现入口流量路由的统一管理 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   └── 实现出口流量路由的统一管理 --> ( 难度等级: [0.0638, 0.0639) || 挂载数据: 无 ) 
│   │   │   ├── 安全 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── Citadel架构设计 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 认证机制 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 授权机制 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用认证策略 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用双向认证 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 消除Privileged容器提升安全性 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 通过NetworkPolicy增强安全性 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   └── Mixer控制与观测 --> ( 难度等级: [0.0639, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── Mixer架构设计 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │       ├── 适配器机制 --> ( 难度等级: [0.0639, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 使用速率限制策略 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 使用黑白名单策略 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 使用基于Zipkin与Jaeger的分布式跟踪 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 集成度量数据收集 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       └── 集成日志数据收集 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   ├── 原理篇 --> ( 难度等级: [0.064, 0.0646) || 挂载数据: 无 ) 
│   │   │   ├── 你好，Istio --> ( 难度等级: [0.064, 0.0641) || 挂载数据: 无 ) 
│   │   │   │   └── 通过示例看看Istio能做什么 --> ( 难度等级: [0.064, 0.0641) || 挂载数据: 无 ) 
│   │   │   ├── Istio架构概述 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio的工作机制 --> ( 难度等级: [0.0641, 0.0641) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio的服务模型 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Istio的服务 --> ( 难度等级: [0.0641, 0.0641) || 挂载数据: blog: 5 ) 
│   │   │   │   │   └── Istio的服务版本 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   └── Istio的主要组件 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-pilot --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 2 ) 
│   │   │   │       ├── istio-telemetry --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-policy --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-citadel --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-galley --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-sidecar-injector --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-proxy --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │       └── istio-ingressgateway --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   ├── 非侵入的流量治理 --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio流量治理的原理 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务熔断 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 故障注入 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 延迟注入 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 中断注入 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 预先准备：将所有流量都路由到各个服务的v1版本 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 基于流量比例的路由 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   ├── 基于请求内容的路由 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 组合条件路由 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 多服务灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── TCP服务灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 自动化灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 正常发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │       └── 异常发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务访问入口 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── 外部接入服务治理 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio路由规则配置：VirtualService --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由规则配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由规则定义 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── HTTP路由（HTTPRoute） --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TLS路由（TLSRoute） --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TCP路由（TCPRoute） --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 三种协议路由规则的对比 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── VirtualService的典型应用 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio目标规则配置：DestinationRule --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── DestinationRule配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── DestinationRule规则定义 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── DestinationRule的典型应用 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务网关配置：Gateway --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Gateway配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Gateway规则定义 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Gateway的典型应用 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Istio外部服务配置：ServiceEntry --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ServiceEntry配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ServiceEntry规则的定义和用法 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── ServiceEntry的典型应用 --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   └── Istio代理规则配置：Sidecar --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │       ├── Sidecar配置示例 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │       └── Sidecar规则定义 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   ├── 可扩展的策略和遥测 --> ( 难度等级: [0.0643, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio策略和遥测的原理 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 应用场景 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工作原理 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: blog: 3 ) 
│   │   │   │   │   ├── 属性 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   └── Mixer的配置模型 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio遥测适配器配置 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Prometheus适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Fluentd适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── StatsD适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Stdio适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Zipkin适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   └── 厂商适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio策略适配器配置 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── List适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Denier适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Memory Quota适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   └── Redis Quota适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes Env适配器配置 --> ( 难度等级: [0.0643, 0.0644) || 挂载数据: 无 ) 
│   │   │   ├── 可插拔的服务安全 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务安全的原理 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 授权 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 命名空间级别的访问控制 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 服务级别的访问控制 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   └── 密钥证书管理 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务认证配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证策略配置示例 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证策略的定义 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TLS访问配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   └── 认证策略的典型应用 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   └── Istio服务授权配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │       ├── 授权启用配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 授权策略配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │       └── 授权策略的典型应用 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   ├── 透明的Sidecar机制 --> ( 难度等级: [0.0644, 0.0645) || 挂载数据: 无 ) 
│   │   │   │   ├── Sidecar注入 --> ( 难度等级: [0.0644, 0.0645) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Sidecar Injector自动注入的原理 --> ( 难度等级: [0.0644, 0.0645) || 挂载数据: 无 ) 
│   │   │   │   │   └── Sidecar注入的实现 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Sidecar流量拦截 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   │       ├── iptables的基本原理 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   │       ├── iptables的规则设置 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   │       └── 流量拦截原理 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   └── 多集群服务治理 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: 无 ) 
│   │   │       ├── Istio多集群服务治理 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │       │   ├── Istio多集群的相关概念 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: blog: 1 ) 
│   │   │       │   └── Istio多集群服务治理现状 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: blog: 9 ) 
│   │   │       ├── 多集群模式1：多控制面 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: 无 ) 
│   │   │       │   ├── 服务DNS解析的原理 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: blog: 1 ) 
│   │   │       │   └── Gateway连接的原理 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: 无 ) 
│   │   │       ├── 多集群模式2：VPN直连单控制面 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: 无 ) 
│   │   │       └── 多集群模式3：集群感知服务路由单控制面 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: 无 ) 
│   │   ├── 实践篇 --> ( 难度等级: [0.0646, 0.0652) || 挂载数据: 无 ) 
│   │   │   ├── 流量监控 --> ( 难度等级: [0.0646, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 调用链跟踪 --> ( 难度等级: [0.0646, 0.0647) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 指标监控 --> ( 难度等级: [0.0647, 0.0647) || 挂载数据: 无 ) 
│   │   │   │   │   └── Grafana --> ( 难度等级: [0.0647, 0.0647) || 挂载数据: 无 ) 
│   │   │   │   └── 服务网格监控 --> ( 难度等级: [0.0647, 0.0648) || 挂载数据: 无 ) 
│   │   │   ├── 流量治理 --> ( 难度等级: [0.0648, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 流量负载均衡 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ROUND_ROBIN模式 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   │   └── RANDOM模式 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 会话保持 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 超时 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 重试 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP重定向 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP重写 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 熔断 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务隔离 --> ( 难度等级: [0.0648, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用流量策略 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置负载均衡 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 管理连接池 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 增强路由规则 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 混沌工程之熔断 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   └── 混沌工程之故障注入 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   ├── 服务保护 --> ( 难度等级: [0.0649, 0.0651) || 挂载数据: 无 ) 
│   │   │   │   ├── 网关加密 --> ( 难度等级: [0.0649, 0.065) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 单向TLS网关 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 双向TLS网关 --> ( 难度等级: [0.0649, 0.065) || 挂载数据: 无 ) 
│   │   │   │   │   └── 用SDS加密网关 --> ( 难度等级: [0.065, 0.065) || 挂载数据: 无 ) 
│   │   │   │   └── 访问控制 --> ( 难度等级: [0.065, 0.0651) || 挂载数据: 无 ) 
│   │   │   │       ├── 黑名单 --> ( 难度等级: [0.065, 0.065) || 挂载数据: 无 ) 
│   │   │   │       └── 白名单 --> ( 难度等级: [0.065, 0.0651) || 挂载数据: 无 ) 
│   │   │   └── 多集群管理 --> ( 难度等级: [0.0651, 0.0652) || 挂载数据: 无 ) 
│   │   ├── 架构篇 --> ( 难度等级: [0.0652, 0.0658) || 挂载数据: 无 ) 
│   │   │   ├── 司令官Pilot --> ( 难度等级: [0.0652, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   ├── Pilot的架构 --> ( 难度等级: [0.0652, 0.0652) || 挂载数据: 无 ) 
│   │   │   │   │   └── xDS协议 --> ( 难度等级: [0.0652, 0.0652) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Pilot的工作流程 --> ( 难度等级: [0.0652, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Pilot的启动与初始化 --> ( 难度等级: [0.0652, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置规则发现 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   └── Envoy的配置分发 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   ├── Pilot的插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 安全插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 健康检查插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   └── Mixer插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot的设计亮点 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       ├── 三级缓存优化 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       ├── 去抖动分发 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       ├── 增量EDS --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       └── 资源隔离 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   ├── 守护神Mixer --> ( 难度等级: [0.0653, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的整体架构 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的服务模型 --> ( 难度等级: [0.0653, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Template --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Adapter --> ( 难度等级: [0.0653, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的工作流程 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动初始化 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用户配置信息规则处理 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 访问策略的执行 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   └── 无侵入遥测 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的设计亮点 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   └── 如何开发Mixer Adapter --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │       ├── Adapter实现概述 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │       ├── 内置式Adapter的开发步骤 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │       ├── 独立进程式Adapter的开发步骤 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 独立仓库式Adapter的开发步骤 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   ├── 安全碉堡Citadel --> ( 难度等级: [0.0654, 0.0655) || 挂载数据: 无 ) 
│   │   │   │   ├── Citadel的架构 --> ( 难度等级: [0.0654, 0.0655) || 挂载数据: 无 ) 
│   │   │   │   └── Citadel的工作流程 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── 启动初始化 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书控制器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── gRPC服务器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书轮换器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       └── SDS服务器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   ├── 高性能代理Envoy --> ( 难度等级: [0.0655, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的架构 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的特性 --> ( 难度等级: [0.0655, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的模块结构 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的线程模型 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的内存管理 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 变量管理 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   │   └── Buffer管理 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Envoy的流量控制 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   ├── 代理守护进程Pilot-agent --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot-agent的工作流程 --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   │   │       ├── Envoy的启动 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │       ├── Envoy的热重启 --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   │   │       ├── 守护Envoy --> ( 难度等级: [0.0657, 0.0657) || 挂载数据: 无 ) 
│   │   │   │       └── 优雅退出 --> ( 难度等级: [0.0657, 0.0657) || 挂载数据: 无 ) 
│   │   │   └── 配置中心Galley --> ( 难度等级: [0.0657, 0.0658) || 挂载数据: 无 ) 
│   │   │       ├── Galley的架构 --> ( 难度等级: [0.0657, 0.0658) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── MCP --> ( 难度等级: [0.0657, 0.0657) || 挂载数据: 无 ) 
│   │   │       │   └── MCP API --> ( 难度等级: [0.0657, 0.0658) || 挂载数据: 无 ) 
│   │   │       └── Galley的工作流程 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   │           ├── 启动初始化 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   │           ├── 配置校验 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   │           └── 配置聚合与分发 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   ├── 源码篇 --> ( 难度等级: [0.0658, 0.0664) || 挂载数据: 无 ) 
│   │   │   ├── Pilot源码解析 --> ( 难度等级: [0.0658, 0.0659) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0658, 0.0659) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       ├── ConfigController --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       ├── ServiceController --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       ├── xDS异步分发 --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       └── 配置更新预处理 --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   ├── Mixer源码解析 --> ( 难度等级: [0.0659, 0.0661) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0659, 0.066) || 挂载数据: 无 ) 
│   │   │   │   │   ├── runServer通过newServer新建Server对象 --> ( 难度等级: [0.0659, 0.066) || 挂载数据: 无 ) 
│   │   │   │   │   └── 启动Mixer gRPC Server --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.066, 0.0661) || 挂载数据: 无 ) 
│   │   │   │       ├── 监听用户的配置 --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │       ├── 构建数据模型 --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │       ├── Check接口 --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │       ├── Report接口 --> ( 难度等级: [0.066, 0.0661) || 挂载数据: 无 ) 
│   │   │   │       └── 协程池 --> ( 难度等级: [0.0661, 0.0661) || 挂载数据: 无 ) 
│   │   │   ├── Citadel源码解析 --> ( 难度等级: [0.0661, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0661, 0.0661) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0661, 0.0662) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书签发实体IstioCA --> ( 难度等级: [0.0661, 0.0661) || 挂载数据: 无 ) 
│   │   │   │       ├── SecretController的创建和核心原理 --> ( 难度等级: [0.0661, 0.0662) || 挂载数据: 无 ) 
│   │   │   │       └── CA Server的创建和核心原理 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   ├── Envoy源码解析 --> ( 难度等级: [0.0662, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动参数bootstrap的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Admin API的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Worker的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── CDS的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── LDS的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   └── GuardDog的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的运行和建立新连接 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动worker --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Listener的加载 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   └── 接收连接 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Envoy对数据的读取、接收及处理 --> ( 难度等级: [0.0662, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 读取数据 --> ( 难度等级: [0.0662, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   │   └── 接收数据 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   └── Envoy发送数据到服务端 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │       ├── 匹配路由 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │       ├── 获取连接池 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │       └── 选择上游主机 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   └── Galley源码解析 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │       ├── 进程启动流程 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │       │   ├── RunServer的启动流程 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │       │   └── RunValidation Server的启动流程 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │       └── 关键代码分析 --> ( 难度等级: [0.0664, 0.0664) || 挂载数据: 无 ) 
│   │   │           ├── 配置监听 --> ( 难度等级: [0.0664, 0.0664) || 挂载数据: 无 ) 
│   │   │           └── 配置分发 --> ( 难度等级: [0.0664, 0.0664) || 挂载数据: 无 ) 
│   │   ├── 初级篇 --> ( 难度等级: [0.0664, 0.067) || 挂载数据: 无 ) 
│   │   │   ├── 快速上手Istio --> ( 难度等级: [0.0664, 0.0667) || 挂载数据: 无 ) 
│   │   │   │   ├── 在MiniKube上搭建Istio环境 --> ( 难度等级: [0.0664, 0.0665) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Docker Desktop上搭建Istio环境 --> ( 难度等级: [0.0665, 0.0666) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 使用公有云Istio服务 --> ( 难度等级: [0.0666, 0.0667) || 挂载数据: 无 ) 
│   │   │   │   └── 在Istio中部署第一个应用程序 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │   └── Istio架构剖析 --> ( 难度等级: [0.0667, 0.067) || 挂载数据: 无 ) 
│   │   │       ├── Istio架构总体结构 --> ( 难度等级: [0.0667, 0.0668) || 挂载数据: 无 ) 
│   │   │       ├── 剖析Istio控制平面 --> ( 难度等级: [0.0668, 0.0669) || 挂载数据: 无 ) 
│   │   │       │   └── Istio Mixer --> ( 难度等级: [0.0668, 0.0669) || 挂载数据: blog: 1 ) 
│   │   │       └── 剖析Istio数据平面 --> ( 难度等级: [0.0669, 0.067) || 挂载数据: 无 ) 
│   │   │           ├── Envoy代理 --> ( 难度等级: [0.0669, 0.067) || 挂载数据: 无 ) 
│   │   │           ├── Envoy静态与动态配置 --> ( 难度等级: [0.067, 0.067) || 挂载数据: 无 ) 
│   │   │           └── 代理部署 --> ( 难度等级: [0.067, 0.067) || 挂载数据: 无 ) 
│   │   ├── 高级篇 --> ( 难度等级: [0.067, 0.0676) || 挂载数据: 无 ) 
│   │   │   ├── Istio的性能分析与运维 --> ( 难度等级: [0.067, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio功能稳定性 --> ( 难度等级: [0.067, 0.0671) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio性能分析 --> ( 难度等级: [0.0671, 0.0671) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Istio组件升级与回滚 --> ( 难度等级: [0.0671, 0.0671) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot运维指南 --> ( 难度等级: [0.0671, 0.0672) || 挂载数据: blog: 9 ) 
│   │   │   ├── Istio的定制与扩展 --> ( 难度等级: [0.0672, 0.0673) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer模板设计 --> ( 难度等级: [0.0672, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   ├── 适配器生命周期管理 --> ( 难度等级: [0.0672, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发实现适配器 --> ( 难度等级: [0.0672, 0.0673) || 挂载数据: 无 ) 
│   │   │   │   ├── 编译与打包适配器 --> ( 难度等级: [0.0673, 0.0673) || 挂载数据: 无 ) 
│   │   │   │   └── 扩展EnvoyFilter --> ( 难度等级: [0.0673, 0.0673) || 挂载数据: 无 ) 
│   │   │   ├── Knative：基于Istio的无服务器计算 --> ( 难度等级: [0.0673, 0.0675) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative架构解析 --> ( 难度等级: [0.0673, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Istio实现Serving组件 --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative Build运行机制 --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative Eventing运行机制 --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Istio上部署Knative --> ( 难度等级: [0.0674, 0.0675) || 挂载数据: 无 ) 
│   │   │   │   └── 开发部署Knative应用 --> ( 难度等级: [0.0675, 0.0675) || 挂载数据: 无 ) 
│   │   │   └── 云原生计算的未来展望 --> ( 难度等级: [0.0675, 0.0676) || 挂载数据: blog: 1 ) 
│   │   ├── 什么是架构 --> ( 难度等级: [0.0676, 0.0682) || 挂载数据: 无 ) 
│   │   ├── 几个相关概念 --> ( 难度等级: [0.0682, 0.0688) || 挂载数据: 无 ) 
│   │   ├── 从软件的生命周期看架构设计 --> ( 难度等级: [0.0688, 0.0694) || 挂载数据: 无 ) 
│   │   ├── 架构的形式与特点 --> ( 难度等级: [0.0694, 0.07) || 挂载数据: 无 ) 
│   │   ├── 架构的目标与方法 --> ( 难度等级: [0.07, 0.0707) || 挂载数据: 无 ) 
│   │   ├── 架构的不同风格 --> ( 难度等级: [0.0707, 0.0713) || 挂载数据: 无 ) 
│   │   ├── 微服务领域驱动设计 --> ( 难度等级: [0.0713, 0.0719) || 挂载数据: 无 ) 
│   │   │   ├── 领域驱动设计 --> ( 难度等级: [0.0713, 0.0716) || 挂载数据: 无 ) 
│   │   │   │   ├── 领域驱动设计概览 --> ( 难度等级: [0.0713, 0.0713) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 限界上下文 --> ( 难度等级: [0.0713, 0.0714) || 挂载数据: 无 ) 
│   │   │   │   ├── 上下文映射 --> ( 难度等级: [0.0714, 0.0715) || 挂载数据: 无 ) 
│   │   │   │   └── 领域架构 --> ( 难度等级: [0.0715, 0.0716) || 挂载数据: 无 ) 
│   │   │   └── 微服务的设计 --> ( 难度等级: [0.0716, 0.0719) || 挂载数据: 无 ) 
│   │   │       ├── 限界上下文的边界 --> ( 难度等级: [0.0716, 0.0716) || 挂载数据: 无 ) 
│   │   │       ├── 限界上下文即微服务 --> ( 难度等级: [0.0716, 0.0717) || 挂载数据: 无 ) 
│   │   │       ├── 识别限界上下文 --> ( 难度等级: [0.0717, 0.0718) || 挂载数据: 无 ) 
│   │   │       └── 微服务之间的协作 --> ( 难度等级: [0.0718, 0.0719) || 挂载数据: blog: 10 ) 
│   │   ├── Apache Dubbo框架的原理与实现 --> ( 难度等级: [0.0719, 0.0725) || 挂载数据: blog: 1 ) 
│   │   │   ├── Dubbo框架的选型与使用 --> ( 难度等级: [0.0719, 0.0721) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo框架的选型 --> ( 难度等级: [0.0719, 0.072) || 挂载数据: 无 ) 
│   │   │   │   └── Dubbo框架的使用 --> ( 难度等级: [0.072, 0.0721) || 挂载数据: blog: 10 ) 
│   │   │   ├── Dubbo框架的原理分析 --> ( 难度等级: [0.0721, 0.0723) || 挂载数据: 无 ) 
│   │   │   │   ├── 总体架构分析 --> ( 难度等级: [0.0721, 0.0721) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo Bean的加载 --> ( 难度等级: [0.0721, 0.0721) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Dubbo Extension机制 --> ( 难度等级: [0.0721, 0.0722) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Dubbo消费端 --> ( 难度等级: [0.0722, 0.0722) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo服务端 --> ( 难度等级: [0.0722, 0.0722) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Dubbo的通信机制 --> ( 难度等级: [0.0722, 0.0723) || 挂载数据: blog: 1 ) 
│   │   │   └── 基于Dubbo的自动化Mock系统 --> ( 难度等级: [0.0723, 0.0725) || 挂载数据: 无 ) 
│   │   │       ├── Mock模拟系统的产生 --> ( 难度等级: [0.0723, 0.0723) || 挂载数据: 无 ) 
│   │   │       ├── Dubbo Mock的使用 --> ( 难度等级: [0.0723, 0.0724) || 挂载数据: 无 ) 
│   │   │       ├── Dubbo Mock的原理解析 --> ( 难度等级: [0.0724, 0.0724) || 挂载数据: blog: 1 ) 
│   │   │       └── 自动化Mock系统的实现 --> ( 难度等级: [0.0724, 0.0725) || 挂载数据: blog: 1 ) 
│   │   ├── Spring Boot/Spring Cloud实践 --> ( 难度等级: [0.0725, 0.0731) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot原理剖析 --> ( 难度等级: [0.0725, 0.0726) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Boot Quick Start --> ( 难度等级: [0.0725, 0.0725) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Spring Boot之SpringApplication --> ( 难度等级: [0.0725, 0.0725) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── spring-boot-loaded模块分析 --> ( 难度等级: [0.0725, 0.0726) || 挂载数据: 无 ) 
│   │   │   │   ├── spring-boot-autoconfigure模块分析 --> ( 难度等级: [0.0726, 0.0726) || 挂载数据: 无 ) 
│   │   │   │   └── Spring Boot Conditional注解分析 --> ( 难度等级: [0.0726, 0.0726) || 挂载数据: blog: 4 ) 
│   │   │   ├── Dubbo Spring Boot Starter --> ( 难度等级: [0.0726, 0.0728) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo Spring Boot Starter简介 --> ( 难度等级: [0.0726, 0.0727) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Dubbo Initializr及sample --> ( 难度等级: [0.0727, 0.0727) || 挂载数据: 无 ) 
│   │   │   │   ├── dubbo-spring-boot-autoconfigure模块 --> ( 难度等级: [0.0727, 0.0727) || 挂载数据: 无 ) 
│   │   │   │   └── dubbo-spring-boot-actuator模块 --> ( 难度等级: [0.0727, 0.0728) || 挂载数据: blog: 1 ) 
│   │   │   ├── Spring Cloud栈 --> ( 难度等级: [0.0728, 0.0729) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud技术栈总览 --> ( 难度等级: [0.0728, 0.0728) || 挂载数据: blog: 5 ) 
│   │   │   │   └── spring-cloud-scaffold基础库集合 --> ( 难度等级: [0.0728, 0.0729) || 挂载数据: blog: 1 ) 
│   │   │   └── 基于Maven Archetype的脚手架 --> ( 难度等级: [0.0729, 0.0731) || 挂载数据: 无 ) 
│   │   │       ├── Maven Archetype --> ( 难度等级: [0.0729, 0.073) || 挂载数据: blog: 10 ) 
│   │   │       ├── 脚手架的搭建 --> ( 难度等级: [0.073, 0.073) || 挂载数据: 无 ) 
│   │   │       └── 生成脚手架 --> ( 难度等级: [0.073, 0.0731) || 挂载数据: 无 ) 
│   │   ├── 微服务稳定性保证的常用手段 --> ( 难度等级: [0.0731, 0.0737) || 挂载数据: 无 ) 
│   │   │   ├── 微服务的稳定性 --> ( 难度等级: [0.0731, 0.0733) || 挂载数据: 无 ) 
│   │   │   ├── 高可用 --> ( 难度等级: [0.0733, 0.0735) || 挂载数据: 无 ) 
│   │   │   │   ├── 限流原理与实现 --> ( 难度等级: [0.0733, 0.0734) || 挂载数据: 无 ) 
│   │   │   │   └── 断路器原理与实现 --> ( 难度等级: [0.0734, 0.0735) || 挂载数据: 无 ) 
│   │   │   └── 高并发 --> ( 难度等级: [0.0735, 0.0737) || 挂载数据: blog: 1 ) 
│   │   │       ├── 异步 --> ( 难度等级: [0.0735, 0.0736) || 挂载数据: 无 ) 
│   │   │       └── 缓存 --> ( 难度等级: [0.0736, 0.0737) || 挂载数据: 无 ) 
│   │   ├── 微服务下如何保证事务的一致性 --> ( 难度等级: [0.0737, 0.0743) || 挂载数据: 无 ) 
│   │   │   ├── 从本地事务到分布式事务的演变 --> ( 难度等级: [0.0737, 0.0739) || 挂载数据: 无 ) 
│   │   │   ├── 强一致性解决方案 --> ( 难度等级: [0.0739, 0.0741) || 挂载数据: 无 ) 
│   │   │   │   ├── 二阶段提交协议 --> ( 难度等级: [0.0739, 0.074) || 挂载数据: 无 ) 
│   │   │   │   └── 三阶段提交协议 --> ( 难度等级: [0.074, 0.0741) || 挂载数据: 无 ) 
│   │   │   └── 最终一致性解决方案 --> ( 难度等级: [0.0741, 0.0743) || 挂载数据: 无 ) 
│   │   │       ├── TCC模式 --> ( 难度等级: [0.0741, 0.0742) || 挂载数据: 无 ) 
│   │   │       └── 补偿模式 --> ( 难度等级: [0.0742, 0.0743) || 挂载数据: 无 ) 
│   │   ├── 百亿流量微服务网关的设计与实现 --> ( 难度等级: [0.0743, 0.0749) || 挂载数据: 无 ) 
│   │   │   ├── 开源网关的分析与调研 --> ( 难度等级: [0.0743, 0.0746) || 挂载数据: 无 ) 
│   │   │   │   ├── 常见的开源网关介绍 --> ( 难度等级: [0.0743, 0.0744) || 挂载数据: 无 ) 
│   │   │   │   └── 四大开源网关的对比分析 --> ( 难度等级: [0.0744, 0.0746) || 挂载数据: 无 ) 
│   │   │   └── 百亿流量交易系统API网关设计 --> ( 难度等级: [0.0746, 0.0749) || 挂载数据: 无 ) 
│   │   │       └── 业务网关的设计与最佳实践 --> ( 难度等级: [0.0746, 0.0749) || 挂载数据: 无 ) 
│   │   ├── 微服务编排 --> ( 难度等级: [0.0749, 0.0755) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Conductor --> ( 难度等级: [0.0749, 0.075) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Conductor的架构 --> ( 难度等级: [0.075, 0.0752) || 挂载数据: 无 ) 
│   │   │   ├── Conductor的使用案例 --> ( 难度等级: [0.0752, 0.0753) || 挂载数据: 无 ) 
│   │   │   └── Netflix Conductor源码分析 --> ( 难度等级: [0.0753, 0.0755) || 挂载数据: 无 ) 
│   │   │       ├── Client层源码分析 --> ( 难度等级: [0.0753, 0.0754) || 挂载数据: blog: 1 ) 
│   │   │       ├── Server端源码分析 --> ( 难度等级: [0.0754, 0.0754) || 挂载数据: 无 ) 
│   │   │       └── core端源码分析 --> ( 难度等级: [0.0754, 0.0755) || 挂载数据: 无 ) 
│   │   ├── 微服务数据抽取与统计 --> ( 难度等级: [0.0755, 0.0761) || 挂载数据: 无 ) 
│   │   │   ├── 案例小故事 --> ( 难度等级: [0.0755, 0.0756) || 挂载数据: 无 ) 
│   │   │   ├── 数据仓库概述 --> ( 难度等级: [0.0756, 0.0757) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是数据仓库 --> ( 难度等级: [0.0756, 0.0756) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据仓库架构 --> ( 难度等级: [0.0756, 0.0757) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据仓库建模方法 --> ( 难度等级: [0.0757, 0.0757) || 挂载数据: 无 ) 
│   │   │   │   └── 数据统计 --> ( 难度等级: [0.0757, 0.0757) || 挂载数据: blog: 1 ) 
│   │   │   ├── 数据仓库工具Hive --> ( 难度等级: [0.0757, 0.0758) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Hive --> ( 难度等级: [0.0757, 0.0758) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Hive数据库 --> ( 难度等级: [0.0758, 0.0758) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Hive表 --> ( 难度等级: [0.0758, 0.0758) || 挂载数据: 无 ) 
│   │   │   ├── 使用Sqoop抽取数据 --> ( 难度等级: [0.0758, 0.076) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Sqoop --> ( 难度等级: [0.0758, 0.0759) || 挂载数据: 无 ) 
│   │   │   │   └── 将MySQL表数据导入Hive表 --> ( 难度等级: [0.0759, 0.076) || 挂载数据: blog: 4 ) 
│   │   │   └── ETL作业调度 --> ( 难度等级: [0.076, 0.0761) || 挂载数据: blog: 1 ) 
│   │   ├── 微服务双活体系建设 --> ( 难度等级: [0.0761, 0.0767) || 挂载数据: 无 ) 
│   │   │   ├── 系统高可用 --> ( 难度等级: [0.0761, 0.0764) || 挂载数据: 无 ) 
│   │   │   └── 双活数据中心 --> ( 难度等级: [0.0764, 0.0767) || 挂载数据: 无 ) 
│   │   │       ├── 单机房部署 --> ( 难度等级: [0.0764, 0.0765) || 挂载数据: 无 ) 
│   │   │       ├── 双机房部署 --> ( 难度等级: [0.0765, 0.0766) || 挂载数据: 无 ) 
│   │   │       └── 基于支付场景的双活体系建设 --> ( 难度等级: [0.0766, 0.0767) || 挂载数据: 无 ) 
│   │   ├── 基于支付场景下的微服务改造与性能优化 --> ( 难度等级: [0.0767, 0.0773) || 挂载数据: 无 ) 
│   │   │   ├── 支付场景的介绍 --> ( 难度等级: [0.0767, 0.0769) || 挂载数据: 无 ) 
│   │   │   ├── 从代码层面提升微服务架构的性能 --> ( 难度等级: [0.0769, 0.0771) || 挂载数据: 无 ) 
│   │   │   │   ├── 从代码和设计的角度看 --> ( 难度等级: [0.0769, 0.077) || 挂载数据: 无 ) 
│   │   │   │   └── 从整体架构的角度看 --> ( 难度等级: [0.077, 0.0771) || 挂载数据: 无 ) 
│   │   │   └── 微服务架构中常见的一些故障分析技巧 --> ( 难度等级: [0.0771, 0.0773) || 挂载数据: 无 ) 
│   │   ├── 遗留系统的微服务架构改造 --> ( 难度等级: [0.0773, 0.0779) || 挂载数据: 无 ) 
│   │   │   ├── 代码分层结构的转变 --> ( 难度等级: [0.0773, 0.0774) || 挂载数据: 无 ) 
│   │   │   ├── 遗留系统的债券与思考 --> ( 难度等级: [0.0774, 0.0776) || 挂载数据: 无 ) 
│   │   │   ├── 从单体系统拆分服务的方法论 --> ( 难度等级: [0.0776, 0.0777) || 挂载数据: 无 ) 
│   │   │   └── 遗留系统的微服务架构改造 --> ( 难度等级: [0.0777, 0.0779) || 挂载数据: 无 ) 
│   │   │       ├── 从代码重构开始 --> ( 难度等级: [0.0777, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 拆分服务需要面向服务进行架构设计 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 改造是一个渐进的过程 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 单元测试是基石 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 面向失败的设计 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 前后端分离 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: blog: 1 ) 
│   │   │       ├── 共享现有数据库 --> ( 难度等级: [0.0778, 0.0779) || 挂载数据: 无 ) 
│   │   │       ├── 灰度发布的必要性 --> ( 难度等级: [0.0779, 0.0779) || 挂载数据: 无 ) 
│   │   │       └── 日志聚合与全链路监控 --> ( 难度等级: [0.0779, 0.0779) || 挂载数据: 无 ) 
│   │   ├── Service Mesh详解 --> ( 难度等级: [0.0779, 0.0785) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh的背景 --> ( 难度等级: [0.0779, 0.078) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh介绍 --> ( 难度等级: [0.078, 0.0781) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Mesh架构 --> ( 难度等级: [0.078, 0.0781) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Service Mesh能做什么 --> ( 难度等级: [0.0781, 0.0781) || 挂载数据: blog: 2 ) 
│   │   │   ├── Service Mesh的价值 --> ( 难度等级: [0.0781, 0.0783) || 挂载数据: 无 ) 
│   │   │   ├── Istio详解 --> ( 难度等级: [0.0783, 0.0784) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Istio架构 --> ( 难度等级: [0.0783, 0.0783) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据平面 --> ( 难度等级: [0.0783, 0.0783) || 挂载数据: 无 ) 
│   │   │   │   ├── 控制平面 --> ( 难度等级: [0.0783, 0.0784) || 挂载数据: 无 ) 
│   │   │   │   └── Isito案例 --> ( 难度等级: [0.0784, 0.0784) || 挂载数据: 无 ) 
│   │   │   └── Service Mesh展望 --> ( 难度等级: [0.0784, 0.0785) || 挂载数据: 无 ) 
│   │   ├── 深入理解网络 --> ( 难度等级: [0.0785, 0.0791) || 挂载数据: 无 ) 
│   │   │   ├── 从国际互联网开始 --> ( 难度等级: [0.0785, 0.0786) || 挂载数据: 无 ) 
│   │   │   ├── NIO，一本难念的经 --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 难懂的ByteBuffer --> ( 难度等级: [0.0786, 0.0786) || 挂载数据: 无 ) 
│   │   │   │   ├── 晦涩的“非阻塞” --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: 无 ) 
│   │   │   │   └── 复杂的Reactor模型 --> ( 难度等级: [0.0787, 0.0787) || 挂载数据: 无 ) 
│   │   │   ├── AIO，大道至简的设计与苦涩的现实 --> ( 难度等级: [0.0787, 0.0788) || 挂载数据: 无 ) 
│   │   │   ├── HTTP的前世今生 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP的设计思路 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP如何保持状态 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Session的秘密 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 再谈Token --> ( 难度等级: [0.0789, 0.0789) || 挂载数据: 无 ) 
│   │   │   │   └── 分布式Session --> ( 难度等级: [0.0789, 0.0789) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的基石：TCP/IP --> ( 难度等级: [0.0789, 0.079) || 挂载数据: blog: 1 ) 
│   │   │   └── 从CDN到SD-WAN --> ( 难度等级: [0.079, 0.0791) || 挂载数据: 无 ) 
│   │   │       ├── 互联互不通的运营商网络 --> ( 难度等级: [0.079, 0.079) || 挂载数据: 无 ) 
│   │   │       ├── 双线机房的出现 --> ( 难度等级: [0.079, 0.0791) || 挂载数据: 无 ) 
│   │   │       ├── CDN的作用 --> ( 难度等级: [0.0791, 0.0791) || 挂载数据: blog: 2 ) 
│   │   │       └── SD-WAN技术的诞生 --> ( 难度等级: [0.0791, 0.0791) || 挂载数据: 无 ) 
│   │   ├── 分布式系统的经典理论 --> ( 难度等级: [0.0791, 0.0797) || 挂载数据: 无 ) 
│   │   │   ├── 从分布式系统的设计理念说起 --> ( 难度等级: [0.0791, 0.0792) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的一致性原理 --> ( 难度等级: [0.0792, 0.0793) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的基石之ZooKeeper --> ( 难度等级: [0.0793, 0.0794) || 挂载数据: 无 ) 
│   │   │   │   ├── ZooKeeper的原理与功能 --> ( 难度等级: [0.0793, 0.0794) || 挂载数据: blog: 10 ) 
│   │   │   │   └── ZooKeeper的应用场景案例分析 --> ( 难度等级: [0.0794, 0.0794) || 挂载数据: blog: 10 ) 
│   │   │   ├── 经典的CAP理论 --> ( 难度等级: [0.0794, 0.0795) || 挂载数据: blog: 2 ) 
│   │   │   ├── BASE准则，一个影响深远的指导思想 --> ( 难度等级: [0.0795, 0.0796) || 挂载数据: 无 ) 
│   │   │   └── 重新认识分布式事务 --> ( 难度等级: [0.0796, 0.0797) || 挂载数据: 无 ) 
│   │   │       ├── 数据库单机事务的实现原理 --> ( 难度等级: [0.0796, 0.0796) || 挂载数据: blog: 1 ) 
│   │   │       ├── 经典的X/OpenDTP事务模型 --> ( 难度等级: [0.0796, 0.0797) || 挂载数据: 无 ) 
│   │   │       └── 互联网中的分布式事务解决方案 --> ( 难度等级: [0.0797, 0.0797) || 挂载数据: blog: 10 ) 
│   │   ├── 聊聊RPC --> ( 难度等级: [0.0797, 0.0803) || 挂载数据: 无 ) 
│   │   │   ├── 从IPC通信说起 --> ( 难度等级: [0.0797, 0.0799) || 挂载数据: 无 ) 
│   │   │   ├── 古老又有生命力的RPC --> ( 难度等级: [0.0799, 0.08) || 挂载数据: 无 ) 
│   │   │   ├── 从RPC到服务治理框架 --> ( 难度等级: [0.08, 0.0802) || 挂载数据: 无 ) 
│   │   │   └── 基于ZeroC Ice的微服务架构指南 --> ( 难度等级: [0.0802, 0.0803) || 挂载数据: 无 ) 
│   │   │       ├── ZeroC Ice的前世今生 --> ( 难度等级: [0.0802, 0.0802) || 挂载数据: blog: 2 ) 
│   │   │       ├── ZeroC Ice微服务架构指南 --> ( 难度等级: [0.0802, 0.0803) || 挂载数据: 无 ) 
│   │   │       └── 微服务架构概述 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: 无 ) 
│   │   │           ├── 微服务架构兴起的原因 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: 无 ) 
│   │   │           ├── 不得不提的容器技术 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: 无 ) 
│   │   │           └── 如何全面理解微服务架构 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: blog: 10 ) 
│   │   ├── 深入浅析内存 --> ( 难度等级: [0.0803, 0.0809) || 挂载数据: 无 ) 
│   │   │   ├── 你所不知道的内存知识 --> ( 难度等级: [0.0803, 0.0805) || 挂载数据: 无 ) 
│   │   │   │   ├── 复杂的CPU与单纯的内存 --> ( 难度等级: [0.0803, 0.0804) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 深入理解不一致性内存 --> ( 难度等级: [0.0804, 0.0805) || 挂载数据: 无 ) 
│   │   │   ├── 内存计算技术的前世今生 --> ( 难度等级: [0.0805, 0.0806) || 挂载数据: 无 ) 
│   │   │   ├── 内存缓存技术分析 --> ( 难度等级: [0.0806, 0.0808) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存概述 --> ( 难度等级: [0.0806, 0.0807) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存实现的几种方式 --> ( 难度等级: [0.0807, 0.0807) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Memcache的内存管理技术 --> ( 难度等级: [0.0807, 0.0807) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Redis的独特之处 --> ( 难度等级: [0.0807, 0.0808) || 挂载数据: 无 ) 
│   │   │   └── 内存计算产品分析 --> ( 难度等级: [0.0808, 0.0809) || 挂载数据: blog: 1 ) 
│   │   │       ├── SAP HANA --> ( 难度等级: [0.0808, 0.0808) || 挂载数据: blog: 1 ) 
│   │   │       ├── Hazelcast --> ( 难度等级: [0.0808, 0.0809) || 挂载数据: 无 ) 
│   │   │       └── VoltDB --> ( 难度等级: [0.0809, 0.0809) || 挂载数据: 无 ) 
│   │   ├── 深入解析分布式文件存储 --> ( 难度等级: [0.0809, 0.0815) || 挂载数据: 无 ) 
│   │   │   ├── 数据存储进化史 --> ( 难度等级: [0.0809, 0.081) || 挂载数据: 无 ) 
│   │   │   ├── 经典的网络文件系统NFS --> ( 难度等级: [0.081, 0.0811) || 挂载数据: 无 ) 
│   │   │   ├── 高性能计算领域的分布式文件系统 --> ( 难度等级: [0.0811, 0.0812) || 挂载数据: 无 ) 
│   │   │   ├── 企业级分布式文件系统GlusterFS --> ( 难度等级: [0.0812, 0.0813) || 挂载数据: 无 ) 
│   │   │   ├── 创新的Linux分布式存储系统——Ceph --> ( 难度等级: [0.0813, 0.0813) || 挂载数据: blog: 1 ) 
│   │   │   ├── 星际文件系统IPFS --> ( 难度等级: [0.0813, 0.0814) || 挂载数据: 无 ) 
│   │   │   └── 软件定义存储 --> ( 难度等级: [0.0814, 0.0815) || 挂载数据: blog: 1 ) 
│   │   ├── 聊聊分布式计算 --> ( 难度等级: [0.0815, 0.0821) || 挂载数据: 无 ) 
│   │   │   ├── 不得不说的Actor模型 --> ( 难度等级: [0.0815, 0.0817) || 挂载数据: 无 ) 
│   │   │   ├── 初识Akka --> ( 难度等级: [0.0817, 0.0818) || 挂载数据: 无 ) 
│   │   │   ├── 适用面很广的Storm --> ( 难度等级: [0.0818, 0.082) || 挂载数据: blog: 2 ) 
│   │   │   └── MapReduce及其引发的新世界 --> ( 难度等级: [0.082, 0.0821) || 挂载数据: blog: 4 ) 
│   │   ├── 全文检索与消息队列中间件 --> ( 难度等级: [0.0821, 0.0827) || 挂载数据: 无 ) 
│   │   │   ├── 全文检索 --> ( 难度等级: [0.0821, 0.0824) || 挂载数据: 无 ) 
│   │   │   │   ├── Lucene --> ( 难度等级: [0.0821, 0.0822) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Solr --> ( 难度等级: [0.0822, 0.0823) || 挂载数据: 无 ) 
│   │   │   │   └── ElasticSearch --> ( 难度等级: [0.0823, 0.0824) || 挂载数据: blog: 5 ) 
│   │   │   └── 消息队列 --> ( 难度等级: [0.0824, 0.0827) || 挂载数据: blog: 6 ) 
│   │   │       ├── JEE专属的JMS --> ( 难度等级: [0.0824, 0.0825) || 挂载数据: blog: 2 ) 
│   │   │       ├── 生生不息的ActiveMQ --> ( 难度等级: [0.0825, 0.0826) || 挂载数据: blog: 10 ) 
│   │   │       ├── RabbitMQ --> ( 难度等级: [0.0826, 0.0827) || 挂载数据: blog: 10 ) 
│   │   │       └── Kafka --> ( 难度等级: [0.0827, 0.0827) || 挂载数据: blog: 10 ) 
│   │   └── 架构实践 --> ( 难度等级: [0.0827, 0.0833) || 挂载数据: 无 ) 
│   │       ├── 身边购平台实践 --> ( 难度等级: [0.0827, 0.083) || 挂载数据: blog: 1 ) 
│   │       └── DIY一个有难度的分布式集群 --> ( 难度等级: [0.083, 0.0833) || 挂载数据: blog: 2 ) 
│   ├── 编程语言 --> ( 难度等级: [0.0833, 0.125) || 挂载数据: 无 ) 
│   │   ├── Golang --> ( 难度等级: [0.0833, 0.085) || 挂载数据: 无 ) 
│   │   ├── 入门 --> ( 难度等级: [0.085, 0.0867) || 挂载数据: 无 ) 
│   │   │   ├── hello，world --> ( 难度等级: [0.085, 0.0852) || 挂载数据: blog: 1 ) 
│   │   │   ├── 命令行参数 --> ( 难度等级: [0.0852, 0.0854) || 挂载数据: 无 ) 
│   │   │   ├── 找出重复行 --> ( 难度等级: [0.0854, 0.0856) || 挂载数据: 无 ) 
│   │   │   ├── GIF动画 --> ( 难度等级: [0.0856, 0.0858) || 挂载数据: 无 ) 
│   │   │   ├── 获取一个URL --> ( 难度等级: [0.0858, 0.086) || 挂载数据: 无 ) 
│   │   │   ├── 并发获取多个URL --> ( 难度等级: [0.086, 0.0862) || 挂载数据: 无 ) 
│   │   │   ├── 一个Web服务器 --> ( 难度等级: [0.0862, 0.0865) || 挂载数据: 无 ) 
│   │   │   └── 其他内容 --> ( 难度等级: [0.0865, 0.0867) || 挂载数据: 无 ) 
│   │   ├── 程序结构 --> ( 难度等级: [0.0867, 0.0883) || 挂载数据: 无 ) 
│   │   │   ├── 名称 --> ( 难度等级: [0.0867, 0.0869) || 挂载数据: 无 ) 
│   │   │   ├── 声明 --> ( 难度等级: [0.0869, 0.0871) || 挂载数据: 无 ) 
│   │   │   ├── 变量 --> ( 难度等级: [0.0871, 0.0874) || 挂载数据: 无 ) 
│   │   │   │   ├── 短变量声明 --> ( 难度等级: [0.0871, 0.0872) || 挂载数据: 无 ) 
│   │   │   │   ├── 指针 --> ( 难度等级: [0.0872, 0.0873) || 挂载数据: 无 ) 
│   │   │   │   ├── new函数 --> ( 难度等级: [0.0873, 0.0873) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 变量的生命周期 --> ( 难度等级: [0.0873, 0.0874) || 挂载数据: 无 ) 
│   │   │   ├── 赋值 --> ( 难度等级: [0.0874, 0.0876) || 挂载数据: 无 ) 
│   │   │   │   ├── 多重赋值 --> ( 难度等级: [0.0874, 0.0875) || 挂载数据: 无 ) 
│   │   │   │   └── 可赋值性 --> ( 难度等级: [0.0875, 0.0876) || 挂载数据: 无 ) 
│   │   │   ├── 类型声明 --> ( 难度等级: [0.0876, 0.0879) || 挂载数据: 无 ) 
│   │   │   ├── 包和文件 --> ( 难度等级: [0.0879, 0.0881) || 挂载数据: 无 ) 
│   │   │   │   ├── 导入 --> ( 难度等级: [0.0879, 0.088) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 远程导入 --> ( 难度等级: [0.0879, 0.0879) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 命名导入 --> ( 难度等级: [0.0879, 0.088) || 挂载数据: 无 ) 
│   │   │   │   └── 包初始化 --> ( 难度等级: [0.088, 0.0881) || 挂载数据: 无 ) 
│   │   │   └── 作用域 --> ( 难度等级: [0.0881, 0.0883) || 挂载数据: 无 ) 
│   │   ├── 基本数据 --> ( 难度等级: [0.0883, 0.09) || 挂载数据: 无 ) 
│   │   │   ├── 整数 --> ( 难度等级: [0.0883, 0.0886) || 挂载数据: 无 ) 
│   │   │   ├── 浮点数 --> ( 难度等级: [0.0886, 0.0889) || 挂载数据: 无 ) 
│   │   │   ├── 复数 --> ( 难度等级: [0.0889, 0.0892) || 挂载数据: 无 ) 
│   │   │   ├── 布尔值 --> ( 难度等级: [0.0892, 0.0894) || 挂载数据: 无 ) 
│   │   │   ├── 字符串 --> ( 难度等级: [0.0894, 0.0897) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串字面量 --> ( 难度等级: [0.0894, 0.0895) || 挂载数据: 无 ) 
│   │   │   │   ├── Unicode --> ( 难度等级: [0.0895, 0.0896) || 挂载数据: 无 ) 
│   │   │   │   ├── UTF-8 --> ( 难度等级: [0.0896, 0.0896) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串和字节slice --> ( 难度等级: [0.0896, 0.0897) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 字符串和数字的相互转换 --> ( 难度等级: [0.0897, 0.0897) || 挂载数据: 无 ) 
│   │   │   └── 常量 --> ( 难度等级: [0.0897, 0.09) || 挂载数据: 无 ) 
│   │   │       ├── 常量生成器iota --> ( 难度等级: [0.0897, 0.0899) || 挂载数据: 无 ) 
│   │   │       └── 无类型常量 --> ( 难度等级: [0.0899, 0.09) || 挂载数据: 无 ) 
│   │   ├── 复合数据类型 --> ( 难度等级: [0.09, 0.0917) || 挂载数据: 无 ) 
│   │   │   ├── 数组 --> ( 难度等级: [0.09, 0.0903) || 挂载数据: 无 ) 
│   │   │   ├── slice --> ( 难度等级: [0.0903, 0.0906) || 挂载数据: 无 ) 
│   │   │   │   ├── append函数 --> ( 难度等级: [0.0903, 0.0904) || 挂载数据: 无 ) 
│   │   │   │   └── slice就地修改 --> ( 难度等级: [0.0904, 0.0906) || 挂载数据: 无 ) 
│   │   │   ├── map --> ( 难度等级: [0.0906, 0.0908) || 挂载数据: blog: 7 ) 
│   │   │   ├── 结构体 --> ( 难度等级: [0.0908, 0.0911) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构体字面量 --> ( 难度等级: [0.0908, 0.0909) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构体比较 --> ( 难度等级: [0.0909, 0.091) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 结构体嵌套和匿名成员 --> ( 难度等级: [0.091, 0.0911) || 挂载数据: 无 ) 
│   │   │   ├── JSON --> ( 难度等级: [0.0911, 0.0914) || 挂载数据: 无 ) 
│   │   │   └── 文本和HTML模板 --> ( 难度等级: [0.0914, 0.0917) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.0917, 0.0933) || 挂载数据: 无 ) 
│   │   │   ├── 函数声明 --> ( 难度等级: [0.0917, 0.0917) || 挂载数据: 无 ) 
│   │   │   ├── 递归 --> ( 难度等级: [0.0917, 0.0918) || 挂载数据: 无 ) 
│   │   │   ├── 多返回值 --> ( 难度等级: [0.0918, 0.0919) || 挂载数据: 无 ) 
│   │   │   ├── 错误 --> ( 难度等级: [0.0919, 0.092) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误处理策略 --> ( 难度等级: [0.0919, 0.0919) || 挂载数据: 无 ) 
│   │   │   │   └── 文件结束标识 --> ( 难度等级: [0.0919, 0.092) || 挂载数据: 无 ) 
│   │   │   ├── 函数变量 --> ( 难度等级: [0.092, 0.0921) || 挂载数据: 无 ) 
│   │   │   ├── 匿名函数 --> ( 难度等级: [0.0921, 0.0921) || 挂载数据: 无 ) 
│   │   │   ├── 变长函数 --> ( 难度等级: [0.0921, 0.0922) || 挂载数据: 无 ) 
│   │   │   ├── 延迟函数调用 --> ( 难度等级: [0.0922, 0.0923) || 挂载数据: 无 ) 
│   │   │   ├── 宕机 --> ( 难度等级: [0.0923, 0.0924) || 挂载数据: 无 ) 
│   │   │   ├── 恢复 --> ( 难度等级: [0.0924, 0.0925) || 挂载数据: 无 ) 
│   │   │   ├── 基本语法 --> ( 难度等级: [0.0925, 0.0925) || 挂载数据: 无 ) 
│   │   │   ├── 参数和返回值的内存布局 --> ( 难度等级: [0.0925, 0.0926) || 挂载数据: 无 ) 
│   │   │   ├── 函数中的局部变量 --> ( 难度等级: [0.0926, 0.0927) || 挂载数据: 无 ) 
│   │   │   ├── 调用其他函数 --> ( 难度等级: [0.0927, 0.0928) || 挂载数据: blog: 1 ) 
│   │   │   ├── 宏函数 --> ( 难度等级: [0.0928, 0.0929) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用规范 --> ( 难度等级: [0.0929, 0.0929) || 挂载数据: 无 ) 
│   │   │   ├── 高级汇编语言 --> ( 难度等级: [0.0929, 0.093) || 挂载数据: 无 ) 
│   │   │   ├── PCDATA和FUNCDATA --> ( 难度等级: [0.093, 0.0931) || 挂载数据: 无 ) 
│   │   │   ├── 方法函数 --> ( 难度等级: [0.0931, 0.0932) || 挂载数据: 无 ) 
│   │   │   ├── 递归函数： 1到n求和 --> ( 难度等级: [0.0932, 0.0933) || 挂载数据: 无 ) 
│   │   │   └── 闭包函数 --> ( 难度等级: [0.0933, 0.0933) || 挂载数据: 无 ) 
│   │   ├── 方法 --> ( 难度等级: [0.0933, 0.095) || 挂载数据: 无 ) 
│   │   │   ├── 方法声明 --> ( 难度等级: [0.0933, 0.0936) || 挂载数据: 无 ) 
│   │   │   ├── 指针接收者的方法 --> ( 难度等级: [0.0936, 0.0939) || 挂载数据: 无 ) 
│   │   │   ├── 通过结构体内嵌组成类型 --> ( 难度等级: [0.0939, 0.0942) || 挂载数据: 无 ) 
│   │   │   ├── 方法变量与表达式 --> ( 难度等级: [0.0942, 0.0944) || 挂载数据: blog: 1 ) 
│   │   │   ├── 示例：位向量 --> ( 难度等级: [0.0944, 0.0947) || 挂载数据: 无 ) 
│   │   │   └── 封装 --> ( 难度等级: [0.0947, 0.095) || 挂载数据: 无 ) 
│   │   ├── 接口 --> ( 难度等级: [0.095, 0.0967) || 挂载数据: 无 ) 
│   │   │   ├── 接口即约定 --> ( 难度等级: [0.095, 0.0951) || 挂载数据: 无 ) 
│   │   │   ├── 接口类型 --> ( 难度等级: [0.0951, 0.0952) || 挂载数据: 无 ) 
│   │   │   ├── 实现接口 --> ( 难度等级: [0.0952, 0.0953) || 挂载数据: 无 ) 
│   │   │   ├── 使用flag.Value来解析参数 --> ( 难度等级: [0.0953, 0.0954) || 挂载数据: 无 ) 
│   │   │   ├── 接口值 --> ( 难度等级: [0.0954, 0.0955) || 挂载数据: 无 ) 
│   │   │   ├── 使用sort.Interface来排序 --> ( 难度等级: [0.0955, 0.0956) || 挂载数据: blog: 2 ) 
│   │   │   ├── http.Handler接口 --> ( 难度等级: [0.0956, 0.0957) || 挂载数据: 无 ) 
│   │   │   ├── error接口 --> ( 难度等级: [0.0957, 0.0958) || 挂载数据: blog: 2 ) 
│   │   │   ├── 类型断言 --> ( 难度等级: [0.0958, 0.0959) || 挂载数据: 无 ) 
│   │   │   ├── 使用类型断言来识别错误 --> ( 难度等级: [0.0959, 0.096) || 挂载数据: 无 ) 
│   │   │   ├── 通过接口类型断言来查询特性 --> ( 难度等级: [0.096, 0.0961) || 挂载数据: 无 ) 
│   │   │   ├── 类型分支 --> ( 难度等级: [0.0961, 0.0962) || 挂载数据: 无 ) 
│   │   │   ├── 一些建议 --> ( 难度等级: [0.0962, 0.0963) || 挂载数据: 无 ) 
│   │   │   ├── 标准库 --> ( 难度等级: [0.0963, 0.0964) || 挂载数据: 无 ) 
│   │   │   │   ├── 文档与源代码 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   ├── 记录日志 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   │   ├── log包 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: blog: 3 ) 
│   │   │   │   │   ├── 定制的日志记录器 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: blog: 2 ) 
│   │   │   │   │   └── 结论 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   ├── 编码解码 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 解码JSON --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   │   └── 编码JSON --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 输入和输出 --> ( 难度等级: [0.0963, 0.0964) || 挂载数据: 无 ) 
│   │   │   │       ├── Writer和Reader接口 --> ( 难度等级: [0.0963, 0.0964) || 挂载数据: 无 ) 
│   │   │   │       ├── 整合并完成工作 --> ( 难度等级: [0.0964, 0.0964) || 挂载数据: blog: 2 ) 
│   │   │   │       └── 简单的curl --> ( 难度等级: [0.0964, 0.0964) || 挂载数据: 无 ) 
│   │   │   ├── 实现 --> ( 难度等级: [0.0964, 0.0965) || 挂载数据: 无 ) 
│   │   │   ├── 方法集 --> ( 难度等级: [0.0965, 0.0966) || 挂载数据: 无 ) 
│   │   │   └── 多态 --> ( 难度等级: [0.0966, 0.0967) || 挂载数据: 无 ) 
│   │   ├── goroutine和通道 --> ( 难度等级: [0.0967, 0.0983) || 挂载数据: 无 ) 
│   │   │   ├── goroutine --> ( 难度等级: [0.0967, 0.097) || 挂载数据: blog: 1 ) 
│   │   │   ├── 通道 --> ( 难度等级: [0.097, 0.0973) || 挂载数据: 无 ) 
│   │   │   │   ├── 无缓冲通道 --> ( 难度等级: [0.097, 0.0971) || 挂载数据: 无 ) 
│   │   │   │   ├── 管道 --> ( 难度等级: [0.0971, 0.0972) || 挂载数据: 无 ) 
│   │   │   │   ├── 单向通道类型 --> ( 难度等级: [0.0972, 0.0973) || 挂载数据: 无 ) 
│   │   │   │   └── 缓冲通道 --> ( 难度等级: [0.0973, 0.0973) || 挂载数据: 无 ) 
│   │   │   ├── 并行循环 --> ( 难度等级: [0.0973, 0.0977) || 挂载数据: 无 ) 
│   │   │   ├── 使用select多路复用 --> ( 难度等级: [0.0977, 0.098) || 挂载数据: 无 ) 
│   │   │   └── 取消 --> ( 难度等级: [0.098, 0.0983) || 挂载数据: 无 ) 
│   │   ├── 使用共享变量实现并发 --> ( 难度等级: [0.0983, 0.1) || 挂载数据: 无 ) 
│   │   │   ├── 竞态 --> ( 难度等级: [0.0983, 0.0986) || 挂载数据: 无 ) 
│   │   │   ├── 互斥锁：sync.Mutex --> ( 难度等级: [0.0986, 0.0989) || 挂载数据: 无 ) 
│   │   │   ├── 读写互斥锁：sync.RWMutex --> ( 难度等级: [0.0989, 0.0992) || 挂载数据: 无 ) 
│   │   │   ├── 内存同步 --> ( 难度等级: [0.0992, 0.0994) || 挂载数据: 无 ) 
│   │   │   ├── 延迟初始化：sync.Once --> ( 难度等级: [0.0994, 0.0997) || 挂载数据: 无 ) 
│   │   │   └── 竞态检测器 --> ( 难度等级: [0.0997, 0.1) || 挂载数据: 无 ) 
│   │   ├── 包和go工具 --> ( 难度等级: [0.1, 0.1017) || 挂载数据: 无 ) 
│   │   │   ├── 引言 --> ( 难度等级: [0.1, 0.1002) || 挂载数据: 无 ) 
│   │   │   ├── 导入路径 --> ( 难度等级: [0.1002, 0.1005) || 挂载数据: 无 ) 
│   │   │   ├── 包的声明 --> ( 难度等级: [0.1005, 0.1007) || 挂载数据: 无 ) 
│   │   │   ├── 导入声明 --> ( 难度等级: [0.1007, 0.101) || 挂载数据: 无 ) 
│   │   │   ├── 空导入 --> ( 难度等级: [0.101, 0.1012) || 挂载数据: 无 ) 
│   │   │   ├── 包及其命名 --> ( 难度等级: [0.1012, 0.1014) || 挂载数据: 无 ) 
│   │   │   └── go工具 --> ( 难度等级: [0.1014, 0.1017) || 挂载数据: 无 ) 
│   │   │       ├── 工作空间的组织 --> ( 难度等级: [0.1014, 0.1015) || 挂载数据: 无 ) 
│   │   │       ├── 包的下载 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │       ├── 包的构建 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │       ├── 包的文档化 --> ( 难度等级: [0.1015, 0.1016) || 挂载数据: 无 ) 
│   │   │       ├── 内部包 --> ( 难度等级: [0.1016, 0.1016) || 挂载数据: 无 ) 
│   │   │       └── 包的查询 --> ( 难度等级: [0.1016, 0.1017) || 挂载数据: 无 ) 
│   │   ├── 测试 --> ( 难度等级: [0.1017, 0.1033) || 挂载数据: 无 ) 
│   │   │   ├── go test工具 --> ( 难度等级: [0.1017, 0.1019) || 挂载数据: 无 ) 
│   │   │   ├── Test函数 --> ( 难度等级: [0.1019, 0.1022) || 挂载数据: 无 ) 
│   │   │   │   ├── 随机测试 --> ( 难度等级: [0.1019, 0.102) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试命令 --> ( 难度等级: [0.102, 0.102) || 挂载数据: 无 ) 
│   │   │   │   ├── 白盒测试 --> ( 难度等级: [0.102, 0.1021) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部测试包 --> ( 难度等级: [0.1021, 0.1021) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写有效测试 --> ( 难度等级: [0.1021, 0.1022) || 挂载数据: 无 ) 
│   │   │   │   └── 避免脆弱的测试 --> ( 难度等级: [0.1022, 0.1022) || 挂载数据: 无 ) 
│   │   │   ├── 覆盖率 --> ( 难度等级: [0.1022, 0.1025) || 挂载数据: 无 ) 
│   │   │   ├── Benchmark函数 --> ( 难度等级: [0.1025, 0.1028) || 挂载数据: 无 ) 
│   │   │   ├── 性能剖析 --> ( 难度等级: [0.1028, 0.1031) || 挂载数据: 无 ) 
│   │   │   └── Example函数 --> ( 难度等级: [0.1031, 0.1033) || 挂载数据: 无 ) 
│   │   ├── 反射 --> ( 难度等级: [0.1033, 0.105) || 挂载数据: blog: 1 ) 
│   │   │   ├── reflect.Type和reflect.Value --> ( 难度等级: [0.1033, 0.1036) || 挂载数据: 无 ) 
│   │   │   ├── Display：一个递归的值显示器 --> ( 难度等级: [0.1036, 0.1039) || 挂载数据: 无 ) 
│   │   │   ├── 使用reflect.Value来设置值 --> ( 难度等级: [0.1039, 0.1042) || 挂载数据: blog: 1 ) 
│   │   │   ├── 访问结构体字段标签 --> ( 难度等级: [0.1042, 0.1044) || 挂载数据: 无 ) 
│   │   │   ├── 显示类型的方法 --> ( 难度等级: [0.1044, 0.1047) || 挂载数据: 无 ) 
│   │   │   └── 注意事项 --> ( 难度等级: [0.1047, 0.105) || 挂载数据: 无 ) 
│   │   ├── 低级编程 --> ( 难度等级: [0.105, 0.1067) || 挂载数据: 无 ) 
│   │   │   ├── unsafe.Sizeof、Alignof和Offsetof --> ( 难度等级: [0.105, 0.1056) || 挂载数据: 无 ) 
│   │   │   ├── unsafe.Pointer --> ( 难度等级: [0.1056, 0.1061) || 挂载数据: 无 ) 
│   │   │   └── 使用cgo调用C代码 --> ( 难度等级: [0.1061, 0.1067) || 挂载数据: 无 ) 
│   │   ├── 关于Go语言的介绍 --> ( 难度等级: [0.1067, 0.1083) || 挂载数据: 无 ) 
│   │   │   ├── 用Go解决现代编程难题 --> ( 难度等级: [0.1067, 0.1075) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发速度 --> ( 难度等级: [0.1067, 0.1069) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发 --> ( 难度等级: [0.1069, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 竞争状态 --> ( 难度等级: [0.1069, 0.107) || 挂载数据: 无 ) 
│   │   │   │   │   └── 锁住共享资源 --> ( 难度等级: [0.107, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   │       └── 原子函数 --> ( 难度等级: [0.107, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   ├── Go语言的类型系统 --> ( 难度等级: [0.1071, 0.1073) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用户定义的类型 --> ( 难度等级: [0.1071, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 类型的本质 --> ( 难度等级: [0.1071, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 内置类型 --> ( 难度等级: [0.1071, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 引用类型 --> ( 难度等级: [0.1072, 0.1072) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   └── 结构类型 --> ( 难度等级: [0.1072, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 嵌入类型 --> ( 难度等级: [0.1072, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   └── 公开或未公开的标识符 --> ( 难度等级: [0.1072, 0.1073) || 挂载数据: 无 ) 
│   │   │   │   └── 内存管理 --> ( 难度等级: [0.1073, 0.1075) || 挂载数据: 无 ) 
│   │   │   └── 你好，Go --> ( 难度等级: [0.1075, 0.1083) || 挂载数据: 无 ) 
│   │   ├── 快速开始一个Go程序 --> ( 难度等级: [0.1083, 0.11) || 挂载数据: 无 ) 
│   │   │   ├── 程序架构 --> ( 难度等级: [0.1083, 0.1087) || 挂载数据: 无 ) 
│   │   │   ├── main包 --> ( 难度等级: [0.1087, 0.1092) || 挂载数据: 无 ) 
│   │   │   ├── search包 --> ( 难度等级: [0.1092, 0.1096) || 挂载数据: 无 ) 
│   │   │   │   ├── search.go --> ( 难度等级: [0.1092, 0.1093) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── feed.go --> ( 难度等级: [0.1093, 0.1094) || 挂载数据: 无 ) 
│   │   │   │   └── match.go default.go --> ( 难度等级: [0.1094, 0.1096) || 挂载数据: 无 ) 
│   │   │   └── RSS匹配器 --> ( 难度等级: [0.1096, 0.11) || 挂载数据: 无 ) 
│   │   ├── 打包和工具链 --> ( 难度等级: [0.11, 0.1117) || 挂载数据: 无 ) 
│   │   │   ├── 包 --> ( 难度等级: [0.11, 0.1103) || 挂载数据: 无 ) 
│   │   │   │   └── 包名惯例 --> ( 难度等级: [0.11, 0.1103) || 挂载数据: 无 ) 
│   │   │   ├── 函数init --> ( 难度等级: [0.1103, 0.1107) || 挂载数据: 无 ) 
│   │   │   ├── 进一步介绍Go开发工具 --> ( 难度等级: [0.1107, 0.111) || 挂载数据: 无 ) 
│   │   │   │   ├── go vet --> ( 难度等级: [0.1107, 0.1108) || 挂载数据: 无 ) 
│   │   │   │   ├── Go代码格式化 --> ( 难度等级: [0.1108, 0.1109) || 挂载数据: 无 ) 
│   │   │   │   └── Go语言的文档 --> ( 难度等级: [0.1109, 0.111) || 挂载数据: blog: 1 ) 
│   │   │   ├── 与其他Go开发者合作 --> ( 难度等级: [0.111, 0.1113) || 挂载数据: 无 ) 
│   │   │   └── 依赖管理 --> ( 难度等级: [0.1113, 0.1117) || 挂载数据: 无 ) 
│   │   │       ├── 第三方依赖 --> ( 难度等级: [0.1113, 0.1115) || 挂载数据: 无 ) 
│   │   │       └── 对gb的介绍 --> ( 难度等级: [0.1115, 0.1117) || 挂载数据: 无 ) 
│   │   ├── 并发模式 --> ( 难度等级: [0.1117, 0.1133) || 挂载数据: 无 ) 
│   │   │   ├── runner --> ( 难度等级: [0.1117, 0.1122) || 挂载数据: 无 ) 
│   │   │   ├── pool --> ( 难度等级: [0.1122, 0.1128) || 挂载数据: 无 ) 
│   │   │   └── work --> ( 难度等级: [0.1128, 0.1133) || 挂载数据: 无 ) 
│   │   ├── 测试和性能 --> ( 难度等级: [0.1133, 0.115) || 挂载数据: 无 ) 
│   │   │   ├── 单元测试 --> ( 难度等级: [0.1133, 0.1142) || 挂载数据: 无 ) 
│   │   │   │   ├── 基础单元测试 --> ( 难度等级: [0.1133, 0.1135) || 挂载数据: 无 ) 
│   │   │   │   ├── 表组测试 --> ( 难度等级: [0.1135, 0.1137) || 挂载数据: 无 ) 
│   │   │   │   ├── 模仿调用 --> ( 难度等级: [0.1137, 0.114) || 挂载数据: 无 ) 
│   │   │   │   └── 测试服务端点 --> ( 难度等级: [0.114, 0.1142) || 挂载数据: 无 ) 
│   │   │   └── 基准测试 --> ( 难度等级: [0.1142, 0.115) || 挂载数据: 无 ) 
│   │   ├── Go与Web应用 --> ( 难度等级: [0.115, 0.1167) || 挂载数据: 无 ) 
│   │   │   ├── Go与Web应用 --> ( 难度等级: [0.115, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Go语言构建Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go与可扩展Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Go与模块化Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go与可维护的Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   │   └── Go与高性能Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Web应用的工作原理 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP简介 --> ( 难度等级: [0.115, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用的诞生 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP请求 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 幂等的请求方法 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 浏览器对请求方法的支持 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   └── 请求首部 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP响应 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 响应状态码 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   └── 响应首部 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── URI --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── HTTP/2简介 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用的各个组成部分 --> ( 难度等级: [0.1151, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 处理器 --> ( 难度等级: [0.1151, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 模板引擎 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 处理请求 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── ResponseWriter --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── cookie --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 将cookie发送至浏览器 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 从浏览器里面获取cookie --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 6 ) 
│   │   │   │   │   │       └── 使用cookie实现闪现消息 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 内容展示 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Go的模板引擎 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 对模板进行语法分析 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   │   └── 执行模板 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 条件动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 迭代动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 设置动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 包含动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 上下文感知 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 防御XSS攻击 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   │   └── 不对HTML进行转义 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 5 ) 
│   │   │   │   │   │   ├── 嵌套模板 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 通过块动作定义默认模板 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   └── 存储数据 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 内存存储 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │       └── 文件存储 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │           ├── 读取和写入CSV文件 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 6 ) 
│   │   │   │   │           └── gob包 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   └── Hello Go --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   ├── ChitChat论坛 --> ( 难度等级: [0.1152, 0.1154) || 挂载数据: 无 ) 
│   │   │   │   ├── ChitChat简介 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用设计 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据模型 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 请求的接收与处理 --> ( 难度等级: [0.1152, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 多路复用器 --> ( 难度等级: [0.1152, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务静态文件 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建处理器函数 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用cookie进行访问控制 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go的net/http标准库 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 使用Go构建服务器 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Go Web服务器 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │       └── 通过HTTPS提供服务 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 使用模板生成HTML响应 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 安装PostgreSQL --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 在Linux或FreeBSD系统上安装 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Mac OS X系统上安装 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 8 ) 
│   │   │   │   │   └── 在Windows系统上安装 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 连接数据库 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动服务器 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   └── Web应用运作流程回顾 --> ( 难度等级: [0.1153, 0.1154) || 挂载数据: 无 ) 
│   │   │   ├── Web开发简介 --> ( 难度等级: [0.1154, 0.1156) || 挂载数据: 无 ) 
│   │   │   ├── 请求路由 --> ( 难度等级: [0.1156, 0.1157) || 挂载数据: 无 ) 
│   │   │   │   ├── httprouter --> ( 难度等级: [0.1156, 0.1156) || 挂载数据: 无 ) 
│   │   │   │   ├── 原理 --> ( 难度等级: [0.1156, 0.1157) || 挂载数据: 无 ) 
│   │   │   │   └── 压缩检索树创建过程 --> ( 难度等级: [0.1157, 0.1157) || 挂载数据: 无 ) 
│   │   │   ├── 中间件 --> ( 难度等级: [0.1157, 0.1159) || 挂载数据: 无 ) 
│   │   │   │   ├── 代码泥潭 --> ( 难度等级: [0.1157, 0.1158) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用中间件剥离非业务逻辑 --> ( 难度等级: [0.1158, 0.1158) || 挂载数据: 无 ) 
│   │   │   │   ├── 更优雅的中间件写法 --> ( 难度等级: [0.1158, 0.1159) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 哪些事情适合在中间件中做 --> ( 难度等级: [0.1159, 0.1159) || 挂载数据: 无 ) 
│   │   │   ├── 请求校验 --> ( 难度等级: [0.1159, 0.1161) || 挂载数据: 无 ) 
│   │   │   │   ├── 重构请求校验函数 --> ( 难度等级: [0.1159, 0.116) || 挂载数据: 无 ) 
│   │   │   │   └── 用请求校验器解放体力劳动 --> ( 难度等级: [0.116, 0.1161) || 挂载数据: 无 ) 
│   │   │   ├── Database和数据库打交道 --> ( 难度等级: [0.1161, 0.1163) || 挂载数据: 无 ) 
│   │   │   │   ├── 从database/sql讲起 --> ( 难度等级: [0.1161, 0.1162) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 提高生产效率的ORM和 --> ( 难度等级: [0.1162, 0.1162) || 挂载数据: 无 ) 
│   │   │   │   └── 脆弱的数据库 --> ( 难度等级: [0.1162, 0.1163) || 挂载数据: blog: 4 ) 
│   │   │   ├── 服务流量限制 --> ( 难度等级: [0.1163, 0.1165) || 挂载数据: 无 ) 
│   │   │   │   ├── 常见的流量限制手段 --> ( 难度等级: [0.1163, 0.1164) || 挂载数据: 无 ) 
│   │   │   │   └── 服务瓶颈和QoS --> ( 难度等级: [0.1164, 0.1165) || 挂载数据: 无 ) 
│   │   │   └── 灰度发布和A/B测试 --> ( 难度等级: [0.1165, 0.1167) || 挂载数据: 无 ) 
│   │   │       ├── 通过分批次部署实现灰度发布 --> ( 难度等级: [0.1165, 0.1165) || 挂载数据: 无 ) 
│   │   │       ├── 通过业务规则进行灰度发布 --> ( 难度等级: [0.1165, 0.1166) || 挂载数据: 无 ) 
│   │   │       └── 如何实现一套灰度发布系统 --> ( 难度等级: [0.1166, 0.1167) || 挂载数据: 无 ) 
│   │   ├── 语言基础 --> ( 难度等级: [0.1167, 0.1183) || 挂载数据: 无 ) 
│   │   │   ├── Go语言创世纪 --> ( 难度等级: [0.1167, 0.1169) || 挂载数据: 无 ) 
│   │   │   │   ├── 来自贝尔实验室特有基因 --> ( 难度等级: [0.1167, 0.1168) || 挂载数据: 无 ) 
│   │   │   │   └── 你好，世界 --> ( 难度等级: [0.1168, 0.1169) || 挂载数据: 无 ) 
│   │   │   ├── “Hello， World”的革命 --> ( 难度等级: [0.1169, 0.1172) || 挂载数据: 无 ) 
│   │   │   │   ├── B语言——Ken Thompson， --> ( 难度等级: [0.1169, 0.117) || 挂载数据: 无 ) 
│   │   │   │   ├── C语言——Dennis Ritchie，1972— --> ( 难度等级: [0.117, 0.117) || 挂载数据: 无 ) 
│   │   │   │   ├── Newsqueak——Rob Pike， --> ( 难度等级: [0.117, 0.1171) || 挂载数据: 无 ) 
│   │   │   │   ├── Alef——Phil Winterbottom， --> ( 难度等级: [0.1171, 0.1171) || 挂载数据: 无 ) 
│   │   │   │   ├── Limbo——Sean Dorward， Phil Winterbottom， Rob Pike， --> ( 难度等级: [0.1171, 0.1171) || 挂载数据: 无 ) 
│   │   │   │   ├── Go语言——2007— --> ( 难度等级: [0.1171, 0.1172) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 你好，世界!——V2. --> ( 难度等级: [0.1172, 0.1172) || 挂载数据: 无 ) 
│   │   │   ├── 面向并发的内存模型 --> ( 难度等级: [0.1172, 0.1175) || 挂载数据: 无 ) 
│   │   │   │   ├── 原子操作 --> ( 难度等级: [0.1172, 0.1173) || 挂载数据: 无 ) 
│   │   │   │   ├── 顺序一致性内存模型 --> ( 难度等级: [0.1173, 0.1173) || 挂载数据: 无 ) 
│   │   │   │   ├── 初始化顺序 --> ( 难度等级: [0.1173, 0.1174) || 挂载数据: 无 ) 
│   │   │   │   ├── Goroutine的创建 --> ( 难度等级: [0.1174, 0.1174) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于通道的通信 --> ( 难度等级: [0.1174, 0.1175) || 挂载数据: 无 ) 
│   │   │   │   └── 不靠谱的同步 --> ( 难度等级: [0.1175, 0.1175) || 挂载数据: 无 ) 
│   │   │   ├── 常见的并发模式 --> ( 难度等级: [0.1175, 0.1178) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发版本的“Hello， World” --> ( 难度等级: [0.1175, 0.1175) || 挂载数据: 无 ) 
│   │   │   │   ├── 生产者/消费者模型 --> ( 难度等级: [0.1175, 0.1176) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布/订阅模型 --> ( 难度等级: [0.1176, 0.1176) || 挂载数据: 无 ) 
│   │   │   │   ├── 控制并发数 --> ( 难度等级: [0.1176, 0.1176) || 挂载数据: 无 ) 
│   │   │   │   ├── 赢者为王 --> ( 难度等级: [0.1176, 0.1177) || 挂载数据: 无 ) 
│   │   │   │   ├── 素数筛 --> ( 难度等级: [0.1177, 0.1177) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发的安全退出 --> ( 难度等级: [0.1177, 0.1177) || 挂载数据: 无 ) 
│   │   │   │   └── context包 --> ( 难度等级: [0.1177, 0.1178) || 挂载数据: 无 ) 
│   │   │   ├── 错误和异常 --> ( 难度等级: [0.1178, 0.1181) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取错误的上下文 --> ( 难度等级: [0.1178, 0.1179) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误的错误返回 --> ( 难度等级: [0.1179, 0.118) || 挂载数据: 无 ) 
│   │   │   │   └── 剖析异常 --> ( 难度等级: [0.118, 0.1181) || 挂载数据: blog: 1 ) 
│   │   │   └── 补充说明 --> ( 难度等级: [0.1181, 0.1183) || 挂载数据: 无 ) 
│   │   ├── CGO编程 --> ( 难度等级: [0.1183, 0.12) || 挂载数据: 无 ) 
│   │   │   ├── 快速入门 --> ( 难度等级: [0.1183, 0.1185) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 最简CGO程序 --> ( 难度等级: [0.1183, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于C标准库函数输出字符串 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用自己的C函数 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── C代码的模块化 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 用Go重新实现C函数 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向C接口的Go编程 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义整数变量 --> ( 难度等级: [0.1184, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义字符串变量 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义main函数 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   ├── 特殊字符 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   └── 没有分号 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   ├── CGO基础 --> ( 难度等级: [0.1185, 0.1187) || 挂载数据: 无 ) 
│   │   │   │   ├── import "C"语句 --> ( 难度等级: [0.1185, 0.1186) || 挂载数据: 无 ) 
│   │   │   │   ├── #cgo语句 --> ( 难度等级: [0.1186, 0.1186) || 挂载数据: 无 ) 
│   │   │   │   └── build标志条件编译 --> ( 难度等级: [0.1186, 0.1187) || 挂载数据: blog: 1 ) 
│   │   │   ├── 类型转换 --> ( 难度等级: [0.1187, 0.1189) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值类型 --> ( 难度等级: [0.1187, 0.1187) || 挂载数据: 无 ) 
│   │   │   │   ├── Go字符串和切片 --> ( 难度等级: [0.1187, 0.1188) || 挂载数据: 无 ) 
│   │   │   │   ├── 指针间的转换 --> ( 难度等级: [0.1188, 0.1188) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值和指针的转换 --> ( 难度等级: [0.1188, 0.1189) || 挂载数据: 无 ) 
│   │   │   │   └── 切片间的转换 --> ( 难度等级: [0.1189, 0.1189) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用 --> ( 难度等级: [0.1189, 0.1191) || 挂载数据: 无 ) 
│   │   │   │   ├── Go调用C函数 --> ( 难度等级: [0.1189, 0.1189) || 挂载数据: 无 ) 
│   │   │   │   ├── C函数的返回值 --> ( 难度等级: [0.1189, 0.119) || 挂载数据: 无 ) 
│   │   │   │   ├── void函数的返回值 --> ( 难度等级: [0.119, 0.119) || 挂载数据: 无 ) 
│   │   │   │   └── C调用Go导出函数 --> ( 难度等级: [0.119, 0.1191) || 挂载数据: 无 ) 
│   │   │   ├── 内部机制 --> ( 难度等级: [0.1191, 0.1193) || 挂载数据: 无 ) 
│   │   │   │   ├── CGO生成的中间文件 --> ( 难度等级: [0.1191, 0.1191) || 挂载数据: 无 ) 
│   │   │   │   ├── Go调用C函数 --> ( 难度等级: [0.1191, 0.1192) || 挂载数据: 无 ) 
│   │   │   │   └── C调用Go函数 --> ( 难度等级: [0.1192, 0.1193) || 挂载数据: 无 ) 
│   │   │   ├── CGO内存模型 --> ( 难度等级: [0.1193, 0.1194) || 挂载数据: 无 ) 
│   │   │   │   ├── Go访问C内存 --> ( 难度等级: [0.1193, 0.1193) || 挂载数据: 无 ) 
│   │   │   │   ├── C临时访问传入的Go内存 --> ( 难度等级: [0.1193, 0.1194) || 挂载数据: 无 ) 
│   │   │   │   ├── C长期持有Go指针对象 --> ( 难度等级: [0.1194, 0.1194) || 挂载数据: 无 ) 
│   │   │   │   └── 导出C函数不能返回Go内存 --> ( 难度等级: [0.1194, 0.1194) || 挂载数据: 无 ) 
│   │   │   ├── C++类包装 --> ( 难度等级: [0.1194, 0.1196) || 挂载数据: 无 ) 
│   │   │   │   ├── C++类到Go语言对象 --> ( 难度等级: [0.1194, 0.1195) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Go语言对象到C++类 --> ( 难度等级: [0.1195, 0.1196) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 彻底解放C++的this指针 --> ( 难度等级: [0.1196, 0.1196) || 挂载数据: blog: 2 ) 
│   │   │   ├── 静态库和动态库 --> ( 难度等级: [0.1196, 0.1198) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用C静态库 --> ( 难度等级: [0.1196, 0.1197) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用C动态库 --> ( 难度等级: [0.1197, 0.1197) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 导出C静态库 --> ( 难度等级: [0.1197, 0.1197) || 挂载数据: 无 ) 
│   │   │   │   ├── 导出C动态库 --> ( 难度等级: [0.1197, 0.1198) || 挂载数据: 无 ) 
│   │   │   │   └── 导出非main包的函数 --> ( 难度等级: [0.1198, 0.1198) || 挂载数据: 无 ) 
│   │   │   └── 编译和链接参数 --> ( 难度等级: [0.1198, 0.12) || 挂载数据: 无 ) 
│   │   │       ├── 编译参数：CFLAGS/CPPFLAGS/CXXFLAGS --> ( 难度等级: [0.1198, 0.1199) || 挂载数据: 无 ) 
│   │   │       ├── 链接参数：LDFLAGS --> ( 难度等级: [0.1199, 0.1199) || 挂载数据: blog: 1 ) 
│   │   │       ├── pkg-config --> ( 难度等级: [0.1199, 0.1199) || 挂载数据: 无 ) 
│   │   │       ├── go get链 --> ( 难度等级: [0.1199, 0.12) || 挂载数据: 无 ) 
│   │   │       └── 多个非main包中导出C函数 --> ( 难度等级: [0.12, 0.12) || 挂载数据: 无 ) 
│   │   ├── Go汇编语言 --> ( 难度等级: [0.12, 0.1217) || 挂载数据: 无 ) 
│   │   │   ├── 计算机结构 --> ( 难度等级: [0.12, 0.1203) || 挂载数据: 无 ) 
│   │   │   │   ├── 图灵机和BrainFuck语言 --> ( 难度等级: [0.12, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   ├── 《人力资源机器》游戏 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   ├── X86-64体系结构 --> ( 难度等级: [0.1201, 0.1202) || 挂载数据: 无 ) 
│   │   │   │   ├── Go汇编中的伪寄存器 --> ( 难度等级: [0.1202, 0.1203) || 挂载数据: 无 ) 
│   │   │   │   └── X86-64指令集 --> ( 难度等级: [0.1203, 0.1203) || 挂载数据: 无 ) 
│   │   │   ├── 控制流 --> ( 难度等级: [0.1203, 0.1207) || 挂载数据: 无 ) 
│   │   │   │   ├── 顺序执行 --> ( 难度等级: [0.1203, 0.1204) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── if/goto跳转 --> ( 难度等级: [0.1204, 0.1206) || 挂载数据: blog: 10 ) 
│   │   │   │   └── for循环 --> ( 难度等级: [0.1206, 0.1207) || 挂载数据: 无 ) 
│   │   │   ├── 汇编语言的威力 --> ( 难度等级: [0.1207, 0.121) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统调用 --> ( 难度等级: [0.1207, 0.1208) || 挂载数据: 无 ) 
│   │   │   │   ├── 直接调用C函数 --> ( 难度等级: [0.1208, 0.1209) || 挂载数据: 无 ) 
│   │   │   │   └── AVX指令 --> ( 难度等级: [0.1209, 0.121) || 挂载数据: 无 ) 
│   │   │   ├── 例子：Goroutine ID --> ( 难度等级: [0.121, 0.1213) || 挂载数据: 无 ) 
│   │   │   │   ├── 故意设计没有goid --> ( 难度等级: [0.121, 0.1211) || 挂载数据: 无 ) 
│   │   │   │   ├── 纯Go方式获取goid --> ( 难度等级: [0.1211, 0.1211) || 挂载数据: 无 ) 
│   │   │   │   ├── 从g结构体获取goid --> ( 难度等级: [0.1211, 0.1212) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取g结构体对应的接口对象 --> ( 难度等级: [0.1212, 0.1213) || 挂载数据: 无 ) 
│   │   │   │   └── goid的应用：局部存储 --> ( 难度等级: [0.1213, 0.1213) || 挂载数据: 无 ) 
│   │   │   └── Delve调试器 --> ( 难度等级: [0.1213, 0.1217) || 挂载数据: 无 ) 
│   │   │       ├── Delve入门 --> ( 难度等级: [0.1213, 0.1215) || 挂载数据: 无 ) 
│   │   │       └── 调试汇编程序 --> ( 难度等级: [0.1215, 0.1217) || 挂载数据: 无 ) 
│   │   ├── RPC和Protobuf --> ( 难度等级: [0.1217, 0.1233) || 挂载数据: 无 ) 
│   │   │   ├── RPC入门 --> ( 难度等级: [0.1217, 0.1219) || 挂载数据: 无 ) 
│   │   │   │   ├── RPC版“Hello， World” --> ( 难度等级: [0.1217, 0.1217) || 挂载数据: 无 ) 
│   │   │   │   ├── 更安全的RPC接口 --> ( 难度等级: [0.1217, 0.1218) || 挂载数据: 无 ) 
│   │   │   │   ├── 跨语言的RPC --> ( 难度等级: [0.1218, 0.1218) || 挂载数据: blog: 1 ) 
│   │   │   │   └── HTTP上的RPC --> ( 难度等级: [0.1218, 0.1219) || 挂载数据: blog: 10 ) 
│   │   │   ├── Protobuf --> ( 难度等级: [0.1219, 0.1221) || 挂载数据: 无 ) 
│   │   │   │   ├── Protobuf入门 --> ( 难度等级: [0.1219, 0.1219) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 定制代码生成插件 --> ( 难度等级: [0.1219, 0.122) || 挂载数据: 无 ) 
│   │   │   │   └── 自动生成完整的RPC代码 --> ( 难度等级: [0.122, 0.1221) || 挂载数据: 无 ) 
│   │   │   ├── 玩转RPC --> ( 难度等级: [0.1221, 0.1223) || 挂载数据: 无 ) 
│   │   │   │   ├── 客户端RPC的实现原理 --> ( 难度等级: [0.1221, 0.1221) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 基于RPC实现监视功能 --> ( 难度等级: [0.1221, 0.1222) || 挂载数据: 无 ) 
│   │   │   │   ├── 反向RPC --> ( 难度等级: [0.1222, 0.1222) || 挂载数据: 无 ) 
│   │   │   │   └── 上下文信息 --> ( 难度等级: [0.1222, 0.1223) || 挂载数据: 无 ) 
│   │   │   ├── gRPC入门 --> ( 难度等级: [0.1223, 0.1225) || 挂载数据: 无 ) 
│   │   │   │   ├── gRPC技术栈 --> ( 难度等级: [0.1223, 0.1223) || 挂载数据: 无 ) 
│   │   │   │   ├── gRPC入门 --> ( 难度等级: [0.1223, 0.1224) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── gRPC流 --> ( 难度等级: [0.1224, 0.1224) || 挂载数据: 无 ) 
│   │   │   │   └── 发布和订阅模式 --> ( 难度等级: [0.1224, 0.1225) || 挂载数据: 无 ) 
│   │   │   ├── gRPC进阶 --> ( 难度等级: [0.1225, 0.1227) || 挂载数据: 无 ) 
│   │   │   │   ├── 证书认证 --> ( 难度等级: [0.1225, 0.1226) || 挂载数据: 无 ) 
│   │   │   │   ├── Token认证 --> ( 难度等级: [0.1226, 0.1226) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 截取器 --> ( 难度等级: [0.1226, 0.1227) || 挂载数据: 无 ) 
│   │   │   │   └── 和Web服务共存 --> ( 难度等级: [0.1227, 0.1227) || 挂载数据: 无 ) 
│   │   │   ├── gRPC和Protobuf扩展 --> ( 难度等级: [0.1227, 0.1229) || 挂载数据: 无 ) 
│   │   │   │   ├── 验证器 --> ( 难度等级: [0.1227, 0.1228) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── REST接口 --> ( 难度等级: [0.1228, 0.1228) || 挂载数据: 无 ) 
│   │   │   │   └── Nginx --> ( 难度等级: [0.1228, 0.1229) || 挂载数据: blog: 10 ) 
│   │   │   ├── pbgo：基于Protobuf的框架 --> ( 难度等级: [0.1229, 0.1231) || 挂载数据: 无 ) 
│   │   │   │   ├── Protobuf扩展语法 --> ( 难度等级: [0.1229, 0.123) || 挂载数据: 无 ) 
│   │   │   │   ├── 插件中读取扩展信息 --> ( 难度等级: [0.123, 0.123) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成REST代码 --> ( 难度等级: [0.123, 0.1231) || 挂载数据: 无 ) 
│   │   │   │   └── 启动REST服务 --> ( 难度等级: [0.1231, 0.1231) || 挂载数据: 无 ) 
│   │   │   └── grpcurl工具 --> ( 难度等级: [0.1231, 0.1233) || 挂载数据: 无 ) 
│   │   │       ├── 启动反射服务 --> ( 难度等级: [0.1231, 0.1232) || 挂载数据: 无 ) 
│   │   │       ├── 查看服务列表 --> ( 难度等级: [0.1232, 0.1232) || 挂载数据: 无 ) 
│   │   │       ├── 服务的方法列表 --> ( 难度等级: [0.1232, 0.1232) || 挂载数据: 无 ) 
│   │   │       ├── 获取类型信息 --> ( 难度等级: [0.1232, 0.1233) || 挂载数据: 无 ) 
│   │   │       └── 调用方法 --> ( 难度等级: [0.1233, 0.1233) || 挂载数据: 无 ) 
│   │   └── 分布式系统 --> ( 难度等级: [0.1233, 0.125) || 挂载数据: 无 ) 
│   │       ├── 分布式ID生成器 --> ( 难度等级: [0.1233, 0.1236) || 挂载数据: 无 ) 
│   │       │   └── worker_id分配 --> ( 难度等级: [0.1233, 0.1236) || 挂载数据: blog: 8 ) 
│   │       ├── 分布式锁 --> ( 难度等级: [0.1236, 0.1238) || 挂载数据: 无 ) 
│   │       │   ├── 进程内加锁 --> ( 难度等级: [0.1236, 0.1236) || 挂载数据: 无 ) 
│   │       │   ├── 尝试锁 --> ( 难度等级: [0.1236, 0.1237) || 挂载数据: 无 ) 
│   │       │   ├── 基于Redis的setnx --> ( 难度等级: [0.1237, 0.1237) || 挂载数据: 无 ) 
│   │       │   ├── 基于ZooKeeper --> ( 难度等级: [0.1237, 0.1237) || 挂载数据: 无 ) 
│   │       │   ├── 基于etcd --> ( 难度等级: [0.1237, 0.1238) || 挂载数据: blog: 1 ) 
│   │       │   └── 如何选择合适的锁 --> ( 难度等级: [0.1238, 0.1238) || 挂载数据: 无 ) 
│   │       ├── 延时任务系统 --> ( 难度等级: [0.1238, 0.124) || 挂载数据: 无 ) 
│   │       │   ├── 定时器的实现 --> ( 难度等级: [0.1238, 0.1239) || 挂载数据: 无 ) 
│   │       │   ├── 任务分发 --> ( 难度等级: [0.1239, 0.124) || 挂载数据: 无 ) 
│   │       │   └── 数据再平衡和幂等考量 --> ( 难度等级: [0.124, 0.124) || 挂载数据: 无 ) 
│   │       ├── 分布式搜索引擎 --> ( 难度等级: [0.124, 0.1243) || 挂载数据: 无 ) 
│   │       │   ├── 搜索引擎 --> ( 难度等级: [0.124, 0.1242) || 挂载数据: blog: 1 ) 
│   │       │   └── 异构数据同步 --> ( 难度等级: [0.1242, 0.1243) || 挂载数据: 无 ) 
│   │       ├── 负载均衡 --> ( 难度等级: [0.1243, 0.1245) || 挂载数据: 无 ) 
│   │       │   ├── 常见的负载均衡思路 --> ( 难度等级: [0.1243, 0.1244) || 挂载数据: 无 ) 
│   │       │   ├── 基于洗牌算法的负载均衡 --> ( 难度等级: [0.1244, 0.1244) || 挂载数据: blog: 10 ) 
│   │       │   └── 负载均衡算法效果验证 --> ( 难度等级: [0.1244, 0.1245) || 挂载数据: 无 ) 
│   │       ├── 分布式配置管理 --> ( 难度等级: [0.1245, 0.1248) || 挂载数据: 无 ) 
│   │       │   ├── 场景举例 --> ( 难度等级: [0.1245, 0.1246) || 挂载数据: 无 ) 
│   │       │   ├── 使用etcd实现配置更新 --> ( 难度等级: [0.1246, 0.1246) || 挂载数据: 无 ) 
│   │       │   ├── 配置膨胀 --> ( 难度等级: [0.1246, 0.1247) || 挂载数据: 无 ) 
│   │       │   ├── 配置版本管理 --> ( 难度等级: [0.1247, 0.1247) || 挂载数据: 无 ) 
│   │       │   └── 客户端容错 --> ( 难度等级: [0.1247, 0.1248) || 挂载数据: 无 ) 
│   │       └── 分布式爬虫 --> ( 难度等级: [0.1248, 0.125) || 挂载数据: 无 ) 
│   │           ├── 基于colly的单机爬虫 --> ( 难度等级: [0.1248, 0.1248) || 挂载数据: 无 ) 
│   │           ├── 分布式爬虫 --> ( 难度等级: [0.1248, 0.1249) || 挂载数据: blog: 3 ) 
│   │           ├── 结合nats和colly的消息生产 --> ( 难度等级: [0.1249, 0.1249) || 挂载数据: 无 ) 
│   │           └── 结合colly的消息消费 --> ( 难度等级: [0.1249, 0.125) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.125, 0.1667) || 挂载数据: 无 ) 
├── 云原生初阶-平台开发 --> ( 难度等级: [0.1667, 0.3333) || 挂载数据: 无 ) 
│   ├── 容器 --> ( 难度等级: [0.1667, 0.2) || 挂载数据: 无 ) 
│   │   ├── Docker --> ( 难度等级: [0.1667, 0.1778) || 挂载数据: 无 ) 
│   │   ├── 基础入门 --> ( 难度等级: [0.1778, 0.1889) || 挂载数据: 无 ) 
│   │   │   ├── 初识Docker与容器 --> ( 难度等级: [0.1778, 0.1792) || 挂载数据: 无 ) 
│   │   │   ├── 核心概念与安装配置 --> ( 难度等级: [0.1792, 0.1806) || 挂载数据: 无 ) 
│   │   │   │   ├── 核心概念 --> ( 难度等级: [0.1792, 0.1795) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 安装Docker引擎 --> ( 难度等级: [0.1795, 0.1799) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Ubuntu环境下安装Docker --> ( 难度等级: [0.1795, 0.1796) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── CentOS环境下安装Docker --> ( 难度等级: [0.1796, 0.1797) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── 通过脚本安装 --> ( 难度等级: [0.1797, 0.1797) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── macOS环境下安装Docker --> ( 难度等级: [0.1797, 0.1798) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Windows环境下安装Docker --> ( 难度等级: [0.1798, 0.1799) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 配置Docker服务 --> ( 难度等级: [0.1799, 0.1802) || 挂载数据: 无 ) 
│   │   │   │   └── 推荐实践环境 --> ( 难度等级: [0.1802, 0.1806) || 挂载数据: 无 ) 
│   │   │   ├── 使用Docker镜像 --> ( 难度等级: [0.1806, 0.1819) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取镜像 --> ( 难度等级: [0.1806, 0.1808) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看镜像信息 --> ( 难度等级: [0.1808, 0.181) || 挂载数据: 无 ) 
│   │   │   │   ├── 搜寻镜像 --> ( 难度等级: [0.181, 0.1812) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除和清理镜像 --> ( 难度等级: [0.1812, 0.1813) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建镜像 --> ( 难度等级: [0.1813, 0.1815) || 挂载数据: 无 ) 
│   │   │   │   ├── 存出和载入镜像 --> ( 难度等级: [0.1815, 0.1817) || 挂载数据: 无 ) 
│   │   │   │   └── 上传镜像 --> ( 难度等级: [0.1817, 0.1819) || 挂载数据: 无 ) 
│   │   │   ├── 操作Docker容器 --> ( 难度等级: [0.1819, 0.1833) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建容器 --> ( 难度等级: [0.1819, 0.1821) || 挂载数据: 无 ) 
│   │   │   │   ├── 停止容器 --> ( 难度等级: [0.1821, 0.1823) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 进入容器 --> ( 难度等级: [0.1823, 0.1825) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 删除容器 --> ( 难度等级: [0.1825, 0.1827) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 导入和导出容器 --> ( 难度等级: [0.1827, 0.1829) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器 --> ( 难度等级: [0.1829, 0.1831) || 挂载数据: 无 ) 
│   │   │   │   └── 其他容器命令 --> ( 难度等级: [0.1831, 0.1833) || 挂载数据: 无 ) 
│   │   │   ├── 访问Docker仓库 --> ( 难度等级: [0.1833, 0.1847) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker Hub公共镜像市场 --> ( 难度等级: [0.1833, 0.1838) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 第三方镜像市场 --> ( 难度等级: [0.1838, 0.1843) || 挂载数据: 无 ) 
│   │   │   │   └── 搭建本地私有仓库 --> ( 难度等级: [0.1843, 0.1847) || 挂载数据: blog: 1 ) 
│   │   │   ├── Docker数据管理 --> ( 难度等级: [0.1847, 0.1861) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据卷 --> ( 难度等级: [0.1847, 0.1852) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据卷容器 --> ( 难度等级: [0.1852, 0.1856) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 利用数据卷容器来迁移数据 --> ( 难度等级: [0.1856, 0.1861) || 挂载数据: 无 ) 
│   │   │   ├── 端口映射与容器互联 --> ( 难度等级: [0.1861, 0.1875) || 挂载数据: 无 ) 
│   │   │   │   ├── 端口映射实现容器访问 --> ( 难度等级: [0.1861, 0.1868) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 互联机制实现便捷互访 --> ( 难度等级: [0.1868, 0.1875) || 挂载数据: 无 ) 
│   │   │   └── 使用Dockerfile创建镜像 --> ( 难度等级: [0.1875, 0.1889) || 挂载数据: 无 ) 
│   │   │       ├── 基本结构 --> ( 难度等级: [0.1875, 0.1878) || 挂载数据: 无 ) 
│   │   │       ├── 指令说明 --> ( 难度等级: [0.1878, 0.1882) || 挂载数据: 无 ) 
│   │   │       │   ├── 配置指令 --> ( 难度等级: [0.1878, 0.188) || 挂载数据: 无 ) 
│   │   │       │   └── 操作指令 --> ( 难度等级: [0.188, 0.1882) || 挂载数据: blog: 1 ) 
│   │   │       ├── 创建镜像 --> ( 难度等级: [0.1882, 0.1885) || 挂载数据: 无 ) 
│   │   │       │   ├── 命令选项 --> ( 难度等级: [0.1882, 0.1883) || 挂载数据: 无 ) 
│   │   │       │   ├── 选择父镜像 --> ( 难度等级: [0.1883, 0.1884) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用.dockerignore文件 --> ( 难度等级: [0.1884, 0.1885) || 挂载数据: 无 ) 
│   │   │       │   └── 多步骤创建 --> ( 难度等级: [0.1885, 0.1885) || 挂载数据: blog: 5 ) 
│   │   │       └── 最佳实践 --> ( 难度等级: [0.1885, 0.1889) || 挂载数据: 无 ) 
│   │   └── 进阶技能 --> ( 难度等级: [0.1889, 0.2) || 挂载数据: 无 ) 
│   │       ├── 核心实现技术 --> ( 难度等级: [0.1889, 0.1911) || 挂载数据: 无 ) 
│   │       │   ├── 基本架构 --> ( 难度等级: [0.1889, 0.1893) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间 --> ( 难度等级: [0.1893, 0.1898) || 挂载数据: 无 ) 
│   │       │   ├── 控制组 --> ( 难度等级: [0.1898, 0.1902) || 挂载数据: 无 ) 
│   │       │   ├── 联合文件系统 --> ( 难度等级: [0.1902, 0.1907) || 挂载数据: 无 ) 
│   │       │   └── Linux网络虚拟化 --> ( 难度等级: [0.1907, 0.1911) || 挂载数据: 无 ) 
│   │       ├── 配置私有仓库 --> ( 难度等级: [0.1911, 0.1933) || 挂载数据: 无 ) 
│   │       │   ├── 安装Docker Registry --> ( 难度等级: [0.1911, 0.1915) || 挂载数据: 无 ) 
│   │       │   ├── 配置TLS证书 --> ( 难度等级: [0.1915, 0.1919) || 挂载数据: 无 ) 
│   │       │   ├── 管理访问权限 --> ( 难度等级: [0.1919, 0.1922) || 挂载数据: 无 ) 
│   │       │   ├── 配置Registry --> ( 难度等级: [0.1922, 0.1926) || 挂载数据: 无 ) 
│   │       │   ├── 批量管理镜像 --> ( 难度等级: [0.1926, 0.193) || 挂载数据: 无 ) 
│   │       │   └── 使用通知系统 --> ( 难度等级: [0.193, 0.1933) || 挂载数据: 无 ) 
│   │       ├── 安全防护与配置 --> ( 难度等级: [0.1933, 0.1956) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间隔离的安全 --> ( 难度等级: [0.1933, 0.1937) || 挂载数据: 无 ) 
│   │       │   ├── 控制组资源控制的安全 --> ( 难度等级: [0.1937, 0.1941) || 挂载数据: 无 ) 
│   │       │   ├── 内核能力机制 --> ( 难度等级: [0.1941, 0.1944) || 挂载数据: 无 ) 
│   │       │   ├── Docker服务端的防护 --> ( 难度等级: [0.1944, 0.1948) || 挂载数据: 无 ) 
│   │       │   ├── 更多安全特性的使用 --> ( 难度等级: [0.1948, 0.1952) || 挂载数据: 无 ) 
│   │       │   └── 使用第三方检测工具 --> ( 难度等级: [0.1952, 0.1956) || 挂载数据: 无 ) 
│   │       │       ├── Docker Bench --> ( 难度等级: [0.1952, 0.1954) || 挂载数据: 无 ) 
│   │       │       └── clair --> ( 难度等级: [0.1954, 0.1956) || 挂载数据: 无 ) 
│   │       ├── 高级网络功能 --> ( 难度等级: [0.1956, 0.1978) || 挂载数据: 无 ) 
│   │       │   ├── 启动与配置参数 --> ( 难度等级: [0.1956, 0.1958) || 挂载数据: 无 ) 
│   │       │   ├── 配置容器DNS和主机名 --> ( 难度等级: [0.1958, 0.1961) || 挂载数据: 无 ) 
│   │       │   ├── 容器访问控制 --> ( 难度等级: [0.1961, 0.1964) || 挂载数据: 无 ) 
│   │       │   ├── 映射容器端口到宿主主机的实现 --> ( 难度等级: [0.1964, 0.1967) || 挂载数据: 无 ) 
│   │       │   ├── 配置容器网桥 --> ( 难度等级: [0.1967, 0.1969) || 挂载数据: 无 ) 
│   │       │   ├── 自定义网桥 --> ( 难度等级: [0.1969, 0.1972) || 挂载数据: 无 ) 
│   │       │   ├── 使用OpenvSwitch网桥 --> ( 难度等级: [0.1972, 0.1975) || 挂载数据: 无 ) 
│   │       │   └── 创建一个点到点连接 --> ( 难度等级: [0.1975, 0.1978) || 挂载数据: 无 ) 
│   │       └── libnetwork插件化网络功能 --> ( 难度等级: [0.1978, 0.2) || 挂载数据: 无 ) 
│   │           ├── 容器网络模型 --> ( 难度等级: [0.1978, 0.1985) || 挂载数据: 无 ) 
│   │           ├── Docker网络命令 --> ( 难度等级: [0.1985, 0.1993) || 挂载数据: 无 ) 
│   │           └── 构建跨主机容器网络 --> ( 难度等级: [0.1993, 0.2) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.2, 0.2333) || 挂载数据: 无 ) 
│   │   ├── 管理工具 --> ( 难度等级: [0.2, 0.2011) || 挂载数据: 无 ) 
│   │   │   ├── Kubelens --> ( 难度等级: [0.2, 0.2002) || 挂载数据: 无 ) 
│   │   │   ├── Kuboard --> ( 难度等级: [0.2002, 0.2003) || 挂载数据: 无 ) 
│   │   │   ├── K3S --> ( 难度等级: [0.2003, 0.2005) || 挂载数据: 无 ) 
│   │   │   ├── K9S --> ( 难度等级: [0.2005, 0.2006) || 挂载数据: 无 ) 
│   │   │   ├── Minikube --> ( 难度等级: [0.2006, 0.2008) || 挂载数据: 无 ) 
│   │   │   ├── kubeasz --> ( 难度等级: [0.2008, 0.2009) || 挂载数据: 无 ) 
│   │   │   └── Draft --> ( 难度等级: [0.2009, 0.2011) || 挂载数据: 无 ) 
│   │   ├── Kubernetes入门 --> ( 难度等级: [0.2011, 0.2022) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes是什么 --> ( 难度等级: [0.2011, 0.2014) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes的历史 --> ( 难度等级: [0.2011, 0.2014) || 挂载数据: blog: 10 ) 
│   │   │   ├── 从一个简单的例子开始 --> ( 难度等级: [0.2014, 0.2018) || 挂载数据: 无 ) 
│   │   │   │   ├── 环境准备 --> ( 难度等级: [0.2014, 0.2015) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动MySQL服务 --> ( 难度等级: [0.2015, 0.2016) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动Tomcat应用 --> ( 难度等级: [0.2016, 0.2017) || 挂载数据: blog: 6 ) 
│   │   │   │   └── 通过浏览器访问网页 --> ( 难度等级: [0.2017, 0.2018) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes基本概念和术语 --> ( 难度等级: [0.2018, 0.2022) || 挂载数据: 无 ) 
│   │   │       ├── Master --> ( 难度等级: [0.2018, 0.2018) || 挂载数据: 无 ) 
│   │   │       ├── Node --> ( 难度等级: [0.2018, 0.2018) || 挂载数据: blog: 4 ) 
│   │   │       ├── Pod --> ( 难度等级: [0.2018, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod定义详解 --> ( 难度等级: [0.2018, 0.2018) || 挂载数据: blog: 3 ) 
│   │   │       │   ├── Pod的基本用法 --> ( 难度等级: [0.2018, 0.2019) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── 静态Pod --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod容器共享Volume --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 4 ) 
│   │   │       │   ├── Pod的配置管理 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 在容器内获取Pod信息（Downward API） --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── Pod生命周期和重启策略 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod健康检查 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 8 ) 
│   │   │       │   ├── 玩转Pod调度 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Init Container（初始化容器） --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── Pod的升级和回滚 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod的扩容和缩容 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用StatefulSet搭建MongoDB集群 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── Pod定义文件详解 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 基本操作 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 其他设置 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   └── Pod调度 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       ├── Label（标签） --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       ├── Replication Controller --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       ├── Deployment --> ( 难度等级: [0.2019, 0.202) || 挂载数据: 无 ) 
│   │   │       │   ├── 运行Deployment --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 4 ) 
│   │   │       │   ├── 命令vs配置文件 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── Deployment配置文件简介 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 伸缩 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Failover --> ( 难度等级: [0.2019, 0.202) || 挂载数据: 无 ) 
│   │   │       │   └── 用label控制Pod的位置 --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── Horizontal Pod Autoscaler --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── StatefulSet --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       │   └── 扩容/缩容StatefulSet --> ( 难度等级: [0.202, 0.202) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service（服务） --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── Volume（存储卷） --> ( 难度等级: [0.202, 0.2021) || 挂载数据: blog: 1 ) 
│   │   │       ├── Persistent Volume --> ( 难度等级: [0.2021, 0.2021) || 挂载数据: 无 ) 
│   │   │       ├── Namespace（命名空间） --> ( 难度等级: [0.2021, 0.2021) || 挂载数据: blog: 1 ) 
│   │   │       └── Annotation（注解） --> ( 难度等级: [0.2021, 0.2022) || 挂载数据: 无 ) 
│   │   ├── Kubernetes实践指南 --> ( 难度等级: [0.2022, 0.2032) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes安装与配置 --> ( 难度等级: [0.2022, 0.2025) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统要求 --> ( 难度等级: [0.2022, 0.2022) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用kubeadm工具快速安装Kubernetes集群 --> ( 难度等级: [0.2022, 0.2022) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 以二进制文件方式安装Kubernetes集群 --> ( 难度等级: [0.2022, 0.2023) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Kubernetes集群的安全设置 --> ( 难度等级: [0.2023, 0.2023) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Kubernetes集群的网络配置 --> ( 难度等级: [0.2023, 0.2024) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 内网中的Kubernetes相关配置 --> ( 难度等级: [0.2024, 0.2024) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的版本升级 --> ( 难度等级: [0.2024, 0.2025) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Kubernetes核心服务配置详解 --> ( 难度等级: [0.2025, 0.2025) || 挂载数据: blog: 6 ) 
│   │   │   ├── kubectl命令行工具用法详解 --> ( 难度等级: [0.2025, 0.2029) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl用法概述 --> ( 难度等级: [0.2025, 0.2026) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl子命令详解 --> ( 难度等级: [0.2026, 0.2027) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl参数列表 --> ( 难度等级: [0.2027, 0.2027) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl输出格式 --> ( 难度等级: [0.2027, 0.2028) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl操作示例 --> ( 难度等级: [0.2028, 0.2029) || 挂载数据: 无 ) 
│   │   │   └── 深入掌握Service --> ( 难度等级: [0.2029, 0.2032) || 挂载数据: 无 ) 
│   │   │       ├── Service定义详解 --> ( 难度等级: [0.2029, 0.2029) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service基本用法 --> ( 难度等级: [0.2029, 0.203) || 挂载数据: 无 ) 
│   │   │       ├── Headless Service --> ( 难度等级: [0.203, 0.203) || 挂载数据: 无 ) 
│   │   │       ├── 集群外部访问Pod或Service --> ( 难度等级: [0.203, 0.2031) || 挂载数据: blog: 1 ) 
│   │   │       ├── DNS服务搭建指南 --> ( 难度等级: [0.2031, 0.2031) || 挂载数据: 无 ) 
│   │   │       ├── 自定义DNS和上游DNS服务器 --> ( 难度等级: [0.2031, 0.2032) || 挂载数据: 无 ) 
│   │   │       └── Ingress：HTTP 7层路由机制 --> ( 难度等级: [0.2032, 0.2032) || 挂载数据: 无 ) 
│   │   ├── Kubernetes核心原理 --> ( 难度等级: [0.2032, 0.2043) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes API Server原理分析 --> ( 难度等级: [0.2032, 0.2034) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes API Server概述 --> ( 难度等级: [0.2032, 0.2033) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 独特的Kubernetes Proxy API接口 --> ( 难度等级: [0.2033, 0.2033) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 集群功能模块之间的通信 --> ( 难度等级: [0.2033, 0.2034) || 挂载数据: 无 ) 
│   │   │   ├── Controller Manager原理分析 --> ( 难度等级: [0.2034, 0.2035) || 挂载数据: 无 ) 
│   │   │   │   ├── Node Controller --> ( 难度等级: [0.2034, 0.2034) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ResourceQuota Controller --> ( 难度等级: [0.2034, 0.2034) || 挂载数据: 无 ) 
│   │   │   │   ├── Namespace Controller --> ( 难度等级: [0.2034, 0.2035) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Service Controller与Endpoint Controller --> ( 难度等级: [0.2035, 0.2035) || 挂载数据: blog: 3 ) 
│   │   │   ├── Scheduler原理分析 --> ( 难度等级: [0.2035, 0.2036) || 挂载数据: 无 ) 
│   │   │   ├── kubelet运行机制分析 --> ( 难度等级: [0.2036, 0.2038) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点管理 --> ( 难度等级: [0.2036, 0.2037) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod管理 --> ( 难度等级: [0.2037, 0.2037) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器健康检查 --> ( 难度等级: [0.2037, 0.2037) || 挂载数据: 无 ) 
│   │   │   │   └── cAdvisor资源监控 --> ( 难度等级: [0.2037, 0.2038) || 挂载数据: 无 ) 
│   │   │   ├── kube-proxy运行机制分析 --> ( 难度等级: [0.2038, 0.2039) || 挂载数据: 无 ) 
│   │   │   ├── 深入分析集群安全机制 --> ( 难度等级: [0.2039, 0.204) || 挂载数据: 无 ) 
│   │   │   │   ├── API Server认证管理（Authentication） --> ( 难度等级: [0.2039, 0.2039) || 挂载数据: 无 ) 
│   │   │   │   ├── API Server授木又管理（Authorization） --> ( 难度等级: [0.2039, 0.204) || 挂载数据: 无 ) 
│   │   │   │   ├── Admission Control（准入控制） --> ( 难度等级: [0.204, 0.204) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Service Account --> ( 难度等级: [0.204, 0.204) || 挂载数据: 无 ) 
│   │   │   │   └── Secret私密凭据 --> ( 难度等级: [0.204, 0.204) || 挂载数据: 无 ) 
│   │   │   ├── 网络原理 --> ( 难度等级: [0.204, 0.2042) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络模型 --> ( 难度等级: [0.204, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker的网络基础 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker的网络实现 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的网络实现 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 单主机Docker网络通信 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Host模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Container模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── None模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Bridge模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 基础网络模型的优缺点分析 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   └── 跨主机Docker网络通信 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Flannel网络方案 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: blog: 1 ) 
│   │   │   │   │       ├── Calico网络方案 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: blog: 9 ) 
│   │   │   │   │       └── 网络方案对比分析 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── CNI网络模型 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络策略 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   └── 开源的网络组件 --> ( 难度等级: [0.2041, 0.2042) || 挂载数据: 无 ) 
│   │   │   └── 共享存储原理 --> ( 难度等级: [0.2042, 0.2043) || 挂载数据: 无 ) 
│   │   │       ├── 共享存储机制概述 --> ( 难度等级: [0.2042, 0.2042) || 挂载数据: 无 ) 
│   │   │       ├── PV详解 --> ( 难度等级: [0.2042, 0.2042) || 挂载数据: 无 ) 
│   │   │       ├── PVC详解 --> ( 难度等级: [0.2042, 0.2042) || 挂载数据: 无 ) 
│   │   │       ├── PV和PVC的生命周期 --> ( 难度等级: [0.2042, 0.2043) || 挂载数据: 无 ) 
│   │   │       └── StorageClass详解 --> ( 难度等级: [0.2043, 0.2043) || 挂载数据: 无 ) 
│   │   ├── Kubernetes开发指南 --> ( 难度等级: [0.2043, 0.2054) || 挂载数据: 无 ) 
│   │   │   ├── REST简述 --> ( 难度等级: [0.2043, 0.2047) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes API详解 --> ( 难度等级: [0.2047, 0.205) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes API概述 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── API版本 --> ( 难度等级: [0.2047, 0.2048) || 挂载数据: 无 ) 
│   │   │   │   ├── API Groups（API组） --> ( 难度等级: [0.2048, 0.2049) || 挂载数据: 无 ) 
│   │   │   │   ├── API方法说明 --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: blog: 2 ) 
│   │   │   │   └── API响应说明 --> ( 难度等级: [0.2049, 0.205) || 挂载数据: blog: 1 ) 
│   │   │   └── 使用Java程序访问Kubernetes API --> ( 难度等级: [0.205, 0.2054) || 挂载数据: blog: 10 ) 
│   │   │       ├── Jersey --> ( 难度等级: [0.205, 0.2051) || 挂载数据: blog: 2 ) 
│   │   │       ├── Fabric8 --> ( 难度等级: [0.2051, 0.2053) || 挂载数据: 无 ) 
│   │   │       └── 使用说明 --> ( 难度等级: [0.2053, 0.2054) || 挂载数据: 无 ) 
│   │   ├── Kubernetes运维指南 --> ( 难度等级: [0.2054, 0.2065) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes集群管理指南 --> ( 难度等级: [0.2054, 0.2057) || 挂载数据: 无 ) 
│   │   │   │   ├── Node的管理 --> ( 难度等级: [0.2054, 0.2054) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新资源对象的Label --> ( 难度等级: [0.2054, 0.2054) || 挂载数据: 无 ) 
│   │   │   │   ├── Namespace：集群环境共享与隔离 --> ( 难度等级: [0.2054, 0.2055) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes资源管理 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 资源紧缺时的Pod驱逐机制 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod Disruption Budget（主动驱逐保护） --> ( 难度等级: [0.2055, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes集群的高可用部署方案 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Kubernetes集群监控 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Weave Scope --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 安装Scope --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 使用Scope --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Heapster --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 6 ) 
│   │   │   │   │   │   └── 使用 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   └── Prometheus Operator --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Prometheus架构 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 10 ) 
│   │   │   │   │       ├── Prometheus Operator架构 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 4 ) 
│   │   │   │   │       └── 部署Prometheus Operator --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 集群统一日志管理 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes审计日志（Audit Log） --> ( 难度等级: [0.2056, 0.2057) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Web UI（Dashboard）管理集群 --> ( 难度等级: [0.2057, 0.2057) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Helm：Kubernetes应用包管理工具 --> ( 难度等级: [0.2057, 0.2057) || 挂载数据: blog: 8 ) 
│   │   │   ├── Trouble Shooting指导 --> ( 难度等级: [0.2057, 0.2061) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看系统Event事件 --> ( 难度等级: [0.2057, 0.2058) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器日志 --> ( 难度等级: [0.2058, 0.2059) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看Kubernetes服务日志 --> ( 难度等级: [0.2059, 0.206) || 挂载数据: 无 ) 
│   │   │   │   └── 寻求帮助 --> ( 难度等级: [0.206, 0.2061) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes开发中的新功能 --> ( 难度等级: [0.2061, 0.2065) || 挂载数据: 无 ) 
│   │   │       ├── Pod Preset（运行时参数注入策略） --> ( 难度等级: [0.2061, 0.2062) || 挂载数据: 无 ) 
│   │   │       ├── Cluster Federation（集群联邦） --> ( 难度等级: [0.2062, 0.2062) || 挂载数据: 无 ) 
│   │   │       ├── 容器运行时接口（Container Runtime Interface-CRI） --> ( 难度等级: [0.2062, 0.2063) || 挂载数据: blog: 3 ) 
│   │   │       ├── 对GPU的支持 --> ( 难度等级: [0.2063, 0.2064) || 挂载数据: 无 ) 
│   │   │       └── Kubernetes的演进路线（Roadmap）和开发模式 --> ( 难度等级: [0.2064, 0.2065) || 挂载数据: blog: 1 ) 
│   │   ├── Kubernetes源码导读 --> ( 难度等级: [0.2065, 0.2075) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes源码结构和编译步骤 --> ( 难度等级: [0.2065, 0.2066) || 挂载数据: 无 ) 
│   │   │   ├── kube-apiserver进程源码分析 --> ( 难度等级: [0.2066, 0.2068) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2066, 0.2067) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2067, 0.2068) || 挂载数据: 无 ) 
│   │   │   ├── kube-controller-manager进程源码分析 --> ( 难度等级: [0.2068, 0.2069) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2068, 0.2068) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2068, 0.2069) || 挂载数据: 无 ) 
│   │   │   ├── kube-scheduler进程源码分析 --> ( 难度等级: [0.2069, 0.2071) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2069, 0.207) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.207, 0.2071) || 挂载数据: 无 ) 
│   │   │   ├── kubelet进程源码分析 --> ( 难度等级: [0.2071, 0.2072) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2071, 0.2071) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2071, 0.2072) || 挂载数据: 无 ) 
│   │   │   ├── kube-proxy进程源码分析 --> ( 难度等级: [0.2072, 0.2074) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2072, 0.2073) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2073, 0.2074) || 挂载数据: 无 ) 
│   │   │   └── kubectl进程源码分析 --> ( 难度等级: [0.2074, 0.2075) || 挂载数据: 无 ) 
│   │   │       ├── kubectl create命令 --> ( 难度等级: [0.2074, 0.2075) || 挂载数据: blog: 3 ) 
│   │   │       └── rolling-update命令 --> ( 难度等级: [0.2075, 0.2075) || 挂载数据: 无 ) 
│   │   ├── 先把Kubernetes跑起来 --> ( 难度等级: [0.2075, 0.2086) || 挂载数据: 无 ) 
│   │   │   ├── 先跑起来 --> ( 难度等级: [0.2075, 0.2077) || 挂载数据: 无 ) 
│   │   │   ├── 创建Kubernetes集群 --> ( 难度等级: [0.2077, 0.2079) || 挂载数据: 无 ) 
│   │   │   ├── 部署应用 --> ( 难度等级: [0.2079, 0.2081) || 挂载数据: 无 ) 
│   │   │   ├── 访问应用 --> ( 难度等级: [0.2081, 0.2082) || 挂载数据: 无 ) 
│   │   │   ├── Scale应用 --> ( 难度等级: [0.2082, 0.2084) || 挂载数据: 无 ) 
│   │   │   └── 滚动更新 --> ( 难度等级: [0.2084, 0.2086) || 挂载数据: 无 ) 
│   │   ├── 重要概念 --> ( 难度等级: [0.2086, 0.2097) || 挂载数据: 无 ) 
│   │   ├── 部署Kubernetes Cluster --> ( 难度等级: [0.2097, 0.2108) || 挂载数据: 无 ) 
│   │   │   ├── 安装Docker --> ( 难度等级: [0.2097, 0.21) || 挂载数据: 无 ) 
│   │   │   │   ├── 手动安装模式 --> ( 难度等级: [0.2097, 0.2098) || 挂载数据: 无 ) 
│   │   │   │   ├── Ubuntu中自动化安装Docker --> ( 难度等级: [0.2098, 0.2099) || 挂载数据: 无 ) 
│   │   │   │   └── CentOS中自动化安装Docker --> ( 难度等级: [0.2099, 0.21) || 挂载数据: blog: 2 ) 
│   │   │   ├── 安装kubelet、kubeadm和kubectl --> ( 难度等级: [0.21, 0.2104) || 挂载数据: 无 ) 
│   │   │   └── 用kubeadm创建Cluster --> ( 难度等级: [0.2104, 0.2108) || 挂载数据: blog: 1 ) 
│   │   │       ├── 初始化Master --> ( 难度等级: [0.2104, 0.2105) || 挂载数据: 无 ) 
│   │   │       ├── 配置kubectl --> ( 难度等级: [0.2105, 0.2106) || 挂载数据: 无 ) 
│   │   │       ├── 安装Pod网络 --> ( 难度等级: [0.2106, 0.2107) || 挂载数据: 无 ) 
│   │   │       └── 添加k8s-node1 和k8s-node2 --> ( 难度等级: [0.2107, 0.2108) || 挂载数据: 无 ) 
│   │   ├── Kubernetes架构 --> ( 难度等级: [0.2108, 0.2118) || 挂载数据: 无 ) 
│   │   │   ├── Master节点 --> ( 难度等级: [0.2108, 0.211) || 挂载数据: 无 ) 
│   │   │   ├── Node节点 --> ( 难度等级: [0.211, 0.2113) || 挂载数据: blog: 1 ) 
│   │   │   ├── 完整的架构图 --> ( 难度等级: [0.2113, 0.2116) || 挂载数据: 无 ) 
│   │   │   └── 用例子把它们串起来 --> ( 难度等级: [0.2116, 0.2118) || 挂载数据: 无 ) 
│   │   ├── 运行应用 --> ( 难度等级: [0.2118, 0.2129) || 挂载数据: 无 ) 
│   │   │   ├── DaemonSet --> ( 难度等级: [0.2118, 0.2124) || 挂载数据: 无 ) 
│   │   │   │   ├── kube-flannel-ds --> ( 难度等级: [0.2118, 0.212) || 挂载数据: 无 ) 
│   │   │   │   ├── kube-proxy --> ( 难度等级: [0.212, 0.2122) || 挂载数据: 无 ) 
│   │   │   │   └── 运行自己的DaemonSet --> ( 难度等级: [0.2122, 0.2124) || 挂载数据: 无 ) 
│   │   │   └── Job --> ( 难度等级: [0.2124, 0.2129) || 挂载数据: 无 ) 
│   │   │       ├── Pod失败的情况 --> ( 难度等级: [0.2124, 0.2125) || 挂载数据: 无 ) 
│   │   │       ├── Job的并行性 --> ( 难度等级: [0.2125, 0.2127) || 挂载数据: blog: 2 ) 
│   │   │       └── 定时Job --> ( 难度等级: [0.2127, 0.2129) || 挂载数据: 无 ) 
│   │   ├── 通过Service访问Pod --> ( 难度等级: [0.2129, 0.214) || 挂载数据: 无 ) 
│   │   │   ├── 创建Service --> ( 难度等级: [0.2129, 0.2132) || 挂载数据: 无 ) 
│   │   │   ├── Cluster IP底层实现 --> ( 难度等级: [0.2132, 0.2134) || 挂载数据: blog: 2 ) 
│   │   │   ├── DNS访问Service --> ( 难度等级: [0.2134, 0.2137) || 挂载数据: 无 ) 
│   │   │   └── 外网如何访问Service --> ( 难度等级: [0.2137, 0.214) || 挂载数据: 无 ) 
│   │   ├── Rolling Update --> ( 难度等级: [0.214, 0.2151) || 挂载数据: 无 ) 
│   │   │   └── 实践 --> ( 难度等级: [0.214, 0.2151) || 挂载数据: 无 ) 
│   │   ├── Health Check --> ( 难度等级: [0.2151, 0.2161) || 挂载数据: 无 ) 
│   │   │   ├── 默认的健康检查 --> ( 难度等级: [0.2151, 0.2153) || 挂载数据: 无 ) 
│   │   │   ├── Liveness探测 --> ( 难度等级: [0.2153, 0.2155) || 挂载数据: 无 ) 
│   │   │   ├── Readiness探测 --> ( 难度等级: [0.2155, 0.2157) || 挂载数据: 无 ) 
│   │   │   ├── Health Check在Scale Up中的应用 --> ( 难度等级: [0.2157, 0.2159) || 挂载数据: blog: 2 ) 
│   │   │   └── Health Check在滚动更新中的应用 --> ( 难度等级: [0.2159, 0.2161) || 挂载数据: 无 ) 
│   │   ├── 数据管理 --> ( 难度等级: [0.2161, 0.2172) || 挂载数据: 无 ) 
│   │   │   ├── Volume --> ( 难度等级: [0.2161, 0.2165) || 挂载数据: 无 ) 
│   │   │   │   ├── emptyDir --> ( 难度等级: [0.2161, 0.2162) || 挂载数据: 无 ) 
│   │   │   │   ├── hostPath --> ( 难度等级: [0.2162, 0.2164) || 挂载数据: 无 ) 
│   │   │   │   └── 外部Storage Provider --> ( 难度等级: [0.2164, 0.2165) || 挂载数据: 无 ) 
│   │   │   ├── PersistentVolume & PersistentVolumeClaim --> ( 难度等级: [0.2165, 0.2168) || 挂载数据: 无 ) 
│   │   │   │   ├── NFS PersistentVolume --> ( 难度等级: [0.2165, 0.2166) || 挂载数据: 无 ) 
│   │   │   │   ├── 回收PV --> ( 难度等级: [0.2166, 0.2167) || 挂载数据: 无 ) 
│   │   │   │   └── PV动态供给 --> ( 难度等级: [0.2167, 0.2168) || 挂载数据: 无 ) 
│   │   │   └── 一个数据库例子 --> ( 难度等级: [0.2168, 0.2172) || 挂载数据: 无 ) 
│   │   ├── Secret & Configmap --> ( 难度等级: [0.2172, 0.2183) || 挂载数据: 无 ) 
│   │   │   ├── 创建Secret --> ( 难度等级: [0.2172, 0.2175) || 挂载数据: 无 ) 
│   │   │   ├── 查看Secret --> ( 难度等级: [0.2175, 0.2177) || 挂载数据: 无 ) 
│   │   │   ├── 在Pod中使用Secret --> ( 难度等级: [0.2177, 0.218) || 挂载数据: 无 ) 
│   │   │   │   ├── Volume方式 --> ( 难度等级: [0.2177, 0.2179) || 挂载数据: 无 ) 
│   │   │   │   └── 环境变量方式 --> ( 难度等级: [0.2179, 0.218) || 挂载数据: 无 ) 
│   │   │   └── ConfigMap --> ( 难度等级: [0.218, 0.2183) || 挂载数据: 无 ) 
│   │   ├── Helm—Kubernetes的包管理器 --> ( 难度等级: [0.2183, 0.2194) || 挂载数据: 无 ) 
│   │   │   ├── Why Helm --> ( 难度等级: [0.2183, 0.2185) || 挂载数据: 无 ) 
│   │   │   ├── Helm架构 --> ( 难度等级: [0.2185, 0.2188) || 挂载数据: 无 ) 
│   │   │   ├── 安装Helm --> ( 难度等级: [0.2188, 0.2191) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm客户端 --> ( 难度等级: [0.2188, 0.219) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Tiller服务器 --> ( 难度等级: [0.219, 0.2191) || 挂载数据: 无 ) 
│   │   │   └── chart详解 --> ( 难度等级: [0.2191, 0.2194) || 挂载数据: 无 ) 
│   │   │       ├── chart目录结构 --> ( 难度等级: [0.2191, 0.2191) || 挂载数据: blog: 1 ) 
│   │   │       ├── chart模板 --> ( 难度等级: [0.2191, 0.2192) || 挂载数据: 无 ) 
│   │   │       ├── 再次实践MySQL chart --> ( 难度等级: [0.2192, 0.2192) || 挂载数据: blog: 1 ) 
│   │   │       ├── 升级和回滚release --> ( 难度等级: [0.2192, 0.2193) || 挂载数据: 无 ) 
│   │   │       └── 开发自己的chart --> ( 难度等级: [0.2193, 0.2194) || 挂载数据: 无 ) 
│   │   ├── 网络 --> ( 难度等级: [0.2194, 0.2204) || 挂载数据: 无 ) 
│   │   │   ├── 各种网络方案 --> ( 难度等级: [0.2194, 0.2199) || 挂载数据: 无 ) 
│   │   │   └── Network Policy --> ( 难度等级: [0.2199, 0.2204) || 挂载数据: 无 ) 
│   │   │       ├── 部署Canal --> ( 难度等级: [0.2199, 0.2202) || 挂载数据: 无 ) 
│   │   │       └── 实践Network Policy --> ( 难度等级: [0.2202, 0.2204) || 挂载数据: blog: 3 ) 
│   │   ├── Kubernetes Dashboard --> ( 难度等级: [0.2204, 0.2215) || 挂载数据: 无 ) 
│   │   │   ├── 安装 --> ( 难度等级: [0.2204, 0.2207) || 挂载数据: 无 ) 
│   │   │   ├── 配置登录权限 --> ( 难度等级: [0.2207, 0.221) || 挂载数据: 无 ) 
│   │   │   ├── Dashboard界面结构 --> ( 难度等级: [0.221, 0.2212) || 挂载数据: blog: 7 ) 
│   │   │   └── 典型使用场景 --> ( 难度等级: [0.2212, 0.2215) || 挂载数据: 无 ) 
│   │   │       ├── 部署Deployment --> ( 难度等级: [0.2212, 0.2213) || 挂载数据: 无 ) 
│   │   │       ├── 在线操作 --> ( 难度等级: [0.2213, 0.2214) || 挂载数据: blog: 1 ) 
│   │   │       ├── 查看资源详细信息 --> ( 难度等级: [0.2214, 0.2214) || 挂载数据: 无 ) 
│   │   │       └── 查看Pod日志 --> ( 难度等级: [0.2214, 0.2215) || 挂载数据: 无 ) 
│   │   ├── Kubernetes集群日志管理 --> ( 难度等级: [0.2215, 0.2226) || 挂载数据: 无 ) 
│   │   ├── Docker简介 --> ( 难度等级: [0.2226, 0.2237) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Docker --> ( 难度等级: [0.2226, 0.2229) || 挂载数据: 无 ) 
│   │   │   ├── Docker基本概念 --> ( 难度等级: [0.2229, 0.2233) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像 --> ( 难度等级: [0.2229, 0.2231) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器 --> ( 难度等级: [0.2231, 0.2232) || 挂载数据: 无 ) 
│   │   │   │   └── 镜像仓库 --> ( 难度等级: [0.2232, 0.2233) || 挂载数据: 无 ) 
│   │   │   └── Docker架构及原理 --> ( 难度等级: [0.2233, 0.2237) || 挂载数据: 无 ) 
│   │   │       ├── Docker架构 --> ( 难度等级: [0.2233, 0.2234) || 挂载数据: 无 ) 
│   │   │       ├── Docker原理 --> ( 难度等级: [0.2234, 0.2235) || 挂载数据: 无 ) 
│   │   │       ├── 容器网络 --> ( 难度等级: [0.2235, 0.2236) || 挂载数据: 无 ) 
│   │   │       └── 容器存储 --> ( 难度等级: [0.2236, 0.2237) || 挂载数据: 无 ) 
│   │   ├── 容器引擎 --> ( 难度等级: [0.2237, 0.2247) || 挂载数据: 无 ) 
│   │   │   ├── 容器引擎实现原理 --> ( 难度等级: [0.2237, 0.2239) || 挂载数据: 无 ) 
│   │   │   ├── 容器生命周期管理 --> ( 难度等级: [0.2239, 0.2241) || 挂载数据: 无 ) 
│   │   │   ├── 容器状态管理 --> ( 难度等级: [0.2241, 0.2243) || 挂载数据: 无 ) 
│   │   │   ├── 访问运行状态容器 --> ( 难度等级: [0.2243, 0.2245) || 挂载数据: 无 ) 
│   │   │   └── 访问容器内容 --> ( 难度等级: [0.2245, 0.2247) || 挂载数据: 无 ) 
│   │   ├── 镜像管理 --> ( 难度等级: [0.2247, 0.2258) || 挂载数据: 无 ) 
│   │   │   ├── Dockerfile及镜像制作 --> ( 难度等级: [0.2247, 0.2249) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile的作用 --> ( 难度等级: [0.2247, 0.2248) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile文件构成 --> ( 难度等级: [0.2248, 0.2248) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 常用命令集 --> ( 难度等级: [0.2248, 0.2249) || 挂载数据: 无 ) 
│   │   │   │   └── 构建镜像 --> ( 难度等级: [0.2249, 0.2249) || 挂载数据: blog: 1 ) 
│   │   │   ├── 镜像基本操作 --> ( 难度等级: [0.2249, 0.2252) || 挂载数据: 无 ) 
│   │   │   │   ├── 从镜像仓库下载镜像 --> ( 难度等级: [0.2249, 0.225) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将本地镜像上传到镜像仓库 --> ( 难度等级: [0.225, 0.225) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 查看本地镜像 --> ( 难度等级: [0.225, 0.225) || 挂载数据: 无 ) 
│   │   │   │   ├── 导出和导入本地镜像 --> ( 难度等级: [0.225, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建镜像 --> ( 难度等级: [0.2251, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改本地镜像标识 --> ( 难度等级: [0.2251, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   └── 删除本地镜像 --> ( 难度等级: [0.2251, 0.2252) || 挂载数据: blog: 3 ) 
│   │   │   ├── Dockerfile优化 --> ( 难度等级: [0.2252, 0.2254) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile检查项 --> ( 难度等级: [0.2252, 0.2253) || 挂载数据: 无 ) 
│   │   │   │   └── 检查及优化工具 --> ( 难度等级: [0.2253, 0.2254) || 挂载数据: 无 ) 
│   │   │   ├── 操作系统基础镜像制作 --> ( 难度等级: [0.2254, 0.2256) || 挂载数据: 无 ) 
│   │   │   │   ├── 操作系统版本选择 --> ( 难度等级: [0.2254, 0.2254) || 挂载数据: 无 ) 
│   │   │   │   ├── 操作系统参数调整 --> ( 难度等级: [0.2254, 0.2254) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定基础rpm包范围 --> ( 难度等级: [0.2254, 0.2255) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定常用命令范围 --> ( 难度等级: [0.2255, 0.2255) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 操作系统镜像制作过程 --> ( 难度等级: [0.2255, 0.2256) || 挂载数据: blog: 4 ) 
│   │   │   │   └── 系统资源限制配置说明 --> ( 难度等级: [0.2256, 0.2256) || 挂载数据: 无 ) 
│   │   │   └── 容器镜像安全加固 --> ( 难度等级: [0.2256, 0.2258) || 挂载数据: 无 ) 
│   │   │       ├── 容器安全加固规范 --> ( 难度等级: [0.2256, 0.2257) || 挂载数据: 无 ) 
│   │   │       └── 安全检查工具 --> ( 难度等级: [0.2257, 0.2258) || 挂载数据: 无 ) 
│   │   ├── 镜像仓库管理 --> ( 难度等级: [0.2258, 0.2269) || 挂载数据: 无 ) 
│   │   │   ├── Docker Registry --> ( 难度等级: [0.2258, 0.2263) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker Hub --> ( 难度等级: [0.2258, 0.226) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 第三方公共仓库 --> ( 难度等级: [0.226, 0.2262) || 挂载数据: 无 ) 
│   │   │   │   └── 建立私有镜像仓库 --> ( 难度等级: [0.2262, 0.2263) || 挂载数据: 无 ) 
│   │   │   └── Harbor --> ( 难度等级: [0.2263, 0.2269) || 挂载数据: 无 ) 
│   │   │       ├── Harbor架构 --> ( 难度等级: [0.2263, 0.2265) || 挂载数据: blog: 4 ) 
│   │   │       ├── Harbor的镜像同步机制 --> ( 难度等级: [0.2265, 0.2266) || 挂载数据: 无 ) 
│   │   │       ├── Harbor用户认证 --> ( 难度等级: [0.2266, 0.2267) || 挂载数据: 无 ) 
│   │   │       └── Harbor容器镜像安全扫描 --> ( 难度等级: [0.2267, 0.2269) || 挂载数据: blog: 1 ) 
│   │   ├── Docker相关部署实践 --> ( 难度等级: [0.2269, 0.228) || 挂载数据: 无 ) 
│   │   │   ├── MySQL Docker部署实践 --> ( 难度等级: [0.2269, 0.2274) || 挂载数据: 无 ) 
│   │   │   │   ├── MySQL简介 --> ( 难度等级: [0.2269, 0.2272) || 挂载数据: blog: 10 ) 
│   │   │   │   └── MySQL容器化操作实践 --> ( 难度等级: [0.2272, 0.2274) || 挂载数据: blog: 2 ) 
│   │   │   └── Docker支持GPU实践 --> ( 难度等级: [0.2274, 0.228) || 挂载数据: 无 ) 
│   │   │       ├── GPU简介 --> ( 难度等级: [0.2274, 0.2276) || 挂载数据: 无 ) 
│   │   │       ├── CPU与GPU的对比 --> ( 难度等级: [0.2276, 0.2278) || 挂载数据: blog: 2 ) 
│   │   │       └── 通过nvidia-docker使用GPU --> ( 难度等级: [0.2278, 0.228) || 挂载数据: blog: 1 ) 
│   │   ├── Kubernetes简介 --> ( 难度等级: [0.228, 0.229) || 挂载数据: 无 ) 
│   │   │   ├── PaaS简介 --> ( 难度等级: [0.228, 0.2285) || 挂载数据: 无 ) 
│   │   │   │   ├── 传统PaaS系统 --> ( 难度等级: [0.228, 0.2282) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 基于Docker的新型PaaS平台 --> ( 难度等级: [0.2282, 0.2285) || 挂载数据: blog: 10 ) 
│   │   │   └── Kubernetes核心概念 --> ( 难度等级: [0.2285, 0.229) || 挂载数据: 无 ) 
│   │   ├── Pod相关核心技术 --> ( 难度等级: [0.229, 0.2301) || 挂载数据: 无 ) 
│   │   │   ├── Label --> ( 难度等级: [0.229, 0.2296) || 挂载数据: 无 ) 
│   │   │   └── 健康检查 --> ( 难度等级: [0.2296, 0.2301) || 挂载数据: 无 ) 
│   │   │       ├── 流程健康检查 --> ( 难度等级: [0.2296, 0.2298) || 挂载数据: 无 ) 
│   │   │       └── 应用健康检查 --> ( 难度等级: [0.2298, 0.2301) || 挂载数据: 无 ) 
│   │   ├── Kubernetes Service --> ( 难度等级: [0.2301, 0.2312) || 挂载数据: 无 ) 
│   │   │   ├── DNS服务发现机制 --> ( 难度等级: [0.2301, 0.2303) || 挂载数据: 无 ) 
│   │   │   ├── Headless服务 --> ( 难度等级: [0.2303, 0.2305) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes服务 --> ( 难度等级: [0.2305, 0.2308) || 挂载数据: 无 ) 
│   │   │   │   ├── ClusterIP --> ( 难度等级: [0.2305, 0.2306) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── NodePort --> ( 难度等级: [0.2306, 0.2307) || 挂载数据: blog: 1 ) 
│   │   │   │   └── LoadBalancer --> ( 难度等级: [0.2307, 0.2308) || 挂载数据: 无 ) 
│   │   │   ├── 网络策略 --> ( 难度等级: [0.2308, 0.231) || 挂载数据: 无 ) 
│   │   │   └── 完整的Kubernetes服务发布实践 --> ( 难度等级: [0.231, 0.2312) || 挂载数据: 无 ) 
│   │   │       ├── 各Kubernetes集群 --> ( 难度等级: [0.231, 0.231) || 挂载数据: blog: 10 ) 
│   │   │       ├── Ingress服务发布 --> ( 难度等级: [0.231, 0.2311) || 挂载数据: blog: 1 ) 
│   │   │       └── 服务发现 --> ( 难度等级: [0.2311, 0.2312) || 挂载数据: 无 ) 
│   │   ├── Kubernetes存储 --> ( 难度等级: [0.2312, 0.2323) || 挂载数据: 无 ) 
│   │   │   ├── 存储使用场景 --> ( 难度等级: [0.2312, 0.2315) || 挂载数据: 无 ) 
│   │   │   ├── 文件存储的几种形式 --> ( 难度等级: [0.2315, 0.2317) || 挂载数据: 无 ) 
│   │   │   ├── Flex Volume存储管理方案 --> ( 难度等级: [0.2317, 0.232) || 挂载数据: 无 ) 
│   │   │   │   └── 如何实现灵活存储组件 --> ( 难度等级: [0.2317, 0.232) || 挂载数据: 无 ) 
│   │   │   └── 标准化容器存储接口CSI --> ( 难度等级: [0.232, 0.2323) || 挂载数据: 无 ) 
│   │   └── 安全及多租户配额管理 --> ( 难度等级: [0.2323, 0.2333) || 挂载数据: 无 ) 
│   │       └── API服务器认证 --> ( 难度等级: [0.2323, 0.2333) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.2333, 0.2667) || 挂载数据: 无 ) 
│   │   ├── 应用中心 --> ( 难度等级: [0.2333, 0.2353) || 挂载数据: 无 ) 
│   │   │   ├── Helm Hub --> ( 难度等级: [0.2333, 0.2337) || 挂载数据: 无 ) 
│   │   │   ├── Operator Hub --> ( 难度等级: [0.2337, 0.2341) || 挂载数据: 无 ) 
│   │   │   ├── Aliyun App Hub --> ( 难度等级: [0.2341, 0.2345) || 挂载数据: blog: 7 ) 
│   │   │   ├── Kubernetes App Hub --> ( 难度等级: [0.2345, 0.2349) || 挂载数据: 无 ) 
│   │   │   └── Prometheus Exporter Hub --> ( 难度等级: [0.2349, 0.2353) || 挂载数据: 无 ) 
│   │   ├── 运维 --> ( 难度等级: [0.2353, 0.2373) || 挂载数据: 无 ) 
│   │   │   └── 模板 --> ( 难度等级: [0.2353, 0.2373) || 挂载数据: 无 ) 
│   │   │       ├── YAML --> ( 难度等级: [0.2353, 0.2356) || 挂载数据: 无 ) 
│   │   │       ├── Helm --> ( 难度等级: [0.2356, 0.2359) || 挂载数据: 无 ) 
│   │   │       ├── KUDO(Kubernetes Universal Declarative Operator) --> ( 难度等级: [0.2359, 0.2363) || 挂载数据: 无 ) 
│   │   │       ├── OAM(Open Application Model) --> ( 难度等级: [0.2363, 0.2366) || 挂载数据: 无 ) 
│   │   │       ├── OpenKruise --> ( 难度等级: [0.2366, 0.2369) || 挂载数据: 无 ) 
│   │   │       └── MetaController --> ( 难度等级: [0.2369, 0.2373) || 挂载数据: 无 ) 
│   │   ├── 监控 --> ( 难度等级: [0.2373, 0.2392) || 挂载数据: 无 ) 
│   │   │   ├── Prometheus --> ( 难度等级: [0.2373, 0.2379) || 挂载数据: 无 ) 
│   │   │   ├── Grafana --> ( 难度等级: [0.2379, 0.2386) || 挂载数据: 无 ) 
│   │   │   └── Alertmanager --> ( 难度等级: [0.2386, 0.2392) || 挂载数据: 无 ) 
│   │   ├── CI/CD --> ( 难度等级: [0.2392, 0.2412) || 挂载数据: blog: 2 ) 
│   │   │   ├── Jenkins --> ( 难度等级: [0.2392, 0.2397) || 挂载数据: blog: 2 ) 
│   │   │   ├── Argo --> ( 难度等级: [0.2397, 0.2402) || 挂载数据: 无 ) 
│   │   │   ├── Tekton --> ( 难度等级: [0.2402, 0.2407) || 挂载数据: 无 ) 
│   │   │   └── Drone --> ( 难度等级: [0.2407, 0.2412) || 挂载数据: blog: 1 ) 
│   │   ├── 日志 --> ( 难度等级: [0.2412, 0.2431) || 挂载数据: 无 ) 
│   │   │   ├── ELK --> ( 难度等级: [0.2412, 0.2418) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── ElasticSearch --> ( 难度等级: [0.2412, 0.2414) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Logstash --> ( 难度等级: [0.2414, 0.2416) || 挂载数据: 无 ) 
│   │   │   │   └── Kibana --> ( 难度等级: [0.2416, 0.2418) || 挂载数据: blog: 1 ) 
│   │   │   ├── EFK --> ( 难度等级: [0.2418, 0.2425) || 挂载数据: 无 ) 
│   │   │   │   ├── ElasticSearch --> ( 难度等级: [0.2418, 0.242) || 挂载数据: 无 ) 
│   │   │   │   ├── Fluentd --> ( 难度等级: [0.242, 0.2423) || 挂载数据: 无 ) 
│   │   │   │   └── Kibana --> ( 难度等级: [0.2423, 0.2425) || 挂载数据: 无 ) 
│   │   │   └── Loki --> ( 难度等级: [0.2425, 0.2431) || 挂载数据: 无 ) 
│   │   │       ├── Loki --> ( 难度等级: [0.2425, 0.2427) || 挂载数据: 无 ) 
│   │   │       ├── Promtail --> ( 难度等级: [0.2427, 0.2429) || 挂载数据: 无 ) 
│   │   │       └── Grafana --> ( 难度等级: [0.2429, 0.2431) || 挂载数据: 无 ) 
│   │   ├── 采集 --> ( 难度等级: [0.2431, 0.2451) || 挂载数据: 无 ) 
│   │   │   ├── Logpilot --> ( 难度等级: [0.2431, 0.2438) || 挂载数据: 无 ) 
│   │   │   ├── Fluentbit --> ( 难度等级: [0.2438, 0.2444) || 挂载数据: 无 ) 
│   │   │   └── Fluentd --> ( 难度等级: [0.2444, 0.2451) || 挂载数据: 无 ) 
│   │   ├── DevOps介绍 --> ( 难度等级: [0.2451, 0.2471) || 挂载数据: 无 ) 
│   │   │   ├── 敏捷、持续交付和三步法 --> ( 难度等级: [0.2451, 0.2456) || 挂载数据: 无 ) 
│   │   │   │   ├── 制造业价值流 --> ( 难度等级: [0.2451, 0.2453) || 挂载数据: 无 ) 
│   │   │   │   ├── 技术价值流 --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 聚焦于部署前置时间 --> ( 难度等级: [0.2453, 0.2453) || 挂载数据: 无 ) 
│   │   │   │   │   └── 关注返工指标——%C/A --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: 无 ) 
│   │   │   │   └── 三步工作法：DevOps的基础原则 --> ( 难度等级: [0.2454, 0.2456) || 挂载数据: blog: 10 ) 
│   │   │   ├── 第一步：流动原则 --> ( 难度等级: [0.2456, 0.2461) || 挂载数据: 无 ) 
│   │   │   │   ├── 使工作可见 --> ( 难度等级: [0.2456, 0.2457) || 挂载数据: 无 ) 
│   │   │   │   ├── 限制在制品数 --> ( 难度等级: [0.2457, 0.2458) || 挂载数据: 无 ) 
│   │   │   │   ├── 减小批量大小 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│   │   │   │   ├── 减少交接次数 --> ( 难度等级: [0.2458, 0.2459) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续识别和改善约束点 --> ( 难度等级: [0.2459, 0.246) || 挂载数据: 无 ) 
│   │   │   │   └── 消除价值流中的困境和浪费 --> ( 难度等级: [0.246, 0.2461) || 挂载数据: 无 ) 
│   │   │   ├── 第二步：反馈原则 --> ( 难度等级: [0.2461, 0.2466) || 挂载数据: 无 ) 
│   │   │   │   ├── 在复杂系统中安全地工作 --> ( 难度等级: [0.2461, 0.2462) || 挂载数据: 无 ) 
│   │   │   │   ├── 在源头保障质量 --> ( 难度等级: [0.2462, 0.2464) || 挂载数据: 无 ) 
│   │   │   │   └── 为下游工作中心而优化 --> ( 难度等级: [0.2464, 0.2466) || 挂载数据: 无 ) 
│   │   │   └── 第三步：持续学习与实验原则 --> ( 难度等级: [0.2466, 0.2471) || 挂载数据: 无 ) 
│   │   │       ├── 建立学习型组织和安全文化 --> ( 难度等级: [0.2466, 0.2467) || 挂载数据: 无 ) 
│   │   │       ├── 将日常工作的改进制度化 --> ( 难度等级: [0.2467, 0.2468) || 挂载数据: 无 ) 
│   │   │       ├── 把局部发现转化为全局优化 --> ( 难度等级: [0.2468, 0.2469) || 挂载数据: 无 ) 
│   │   │       ├── 在日常工作中注入弹性模式 --> ( 难度等级: [0.2469, 0.247) || 挂载数据: 无 ) 
│   │   │       └── 领导层强化学习文化 --> ( 难度等级: [0.247, 0.2471) || 挂载数据: blog: 1 ) 
│   │   ├── 从何处开始 --> ( 难度等级: [0.2471, 0.249) || 挂载数据: 无 ) 
│   │   │   ├── 选择合适的价值流作为切入点 --> ( 难度等级: [0.2471, 0.2475) || 挂载数据: 无 ) 
│   │   │   │   ├── 兼顾记录型系统和交互型系统 --> ( 难度等级: [0.2471, 0.2472) || 挂载数据: 无 ) 
│   │   │   │   ├── 从最乐于创新的团队开始 --> ( 难度等级: [0.2472, 0.2474) || 挂载数据: 无 ) 
│   │   │   │   └── 扩大DevOps的范围 --> ( 难度等级: [0.2474, 0.2475) || 挂载数据: 无 ) 
│   │   │   ├── 理解、可视化和运用价值流 --> ( 难度等级: [0.2475, 0.248) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定创造客户价值所需的团队 --> ( 难度等级: [0.2475, 0.2477) || 挂载数据: 无 ) 
│   │   │   │   ├── 针对团队工作绘制价值流图 --> ( 难度等级: [0.2477, 0.2478) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 组建专门的转型团队 --> ( 难度等级: [0.2478, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 拥有共同的目标 --> ( 难度等级: [0.2478, 0.2478) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 保持小跨度的改进计划 --> ( 难度等级: [0.2478, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 为非功能性需求预留20%的开发时间，减少技术债务 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   │   └── 提高工作的可视化程度 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   └── 用工具强化预期行为 --> ( 难度等级: [0.2479, 0.248) || 挂载数据: 无 ) 
│   │   │   ├── 参考康威定律设计组织结构 --> ( 难度等级: [0.248, 0.2485) || 挂载数据: 无 ) 
│   │   │   │   ├── 组织原型 --> ( 难度等级: [0.248, 0.2481) || 挂载数据: 无 ) 
│   │   │   │   ├── 过度职能导向的危害（“成本优化”） --> ( 难度等级: [0.2481, 0.2482) || 挂载数据: 无 ) 
│   │   │   │   ├── 组建以市场为导向的团队（“速度优化”） --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│   │   │   │   ├── 使职能导向有效 --> ( 难度等级: [0.2482, 0.2483) || 挂载数据: 无 ) 
│   │   │   │   ├── 将测试、运维和信息安全融入日常工作 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│   │   │   │   ├── 使团队成员都成为通才 --> ( 难度等级: [0.2483, 0.2484) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据康威定律设定团队边界 --> ( 难度等级: [0.2484, 0.2485) || 挂载数据: 无 ) 
│   │   │   │   └── 创建松耦合架构，提高生产力和安全性 --> ( 难度等级: [0.2485, 0.2485) || 挂载数据: 无 ) 
│   │   │   └── 将运维融入日常开发工作 --> ( 难度等级: [0.2485, 0.249) || 挂载数据: 无 ) 
│   │   │       ├── 创建共享服务，提高开发生产力 --> ( 难度等级: [0.2485, 0.2487) || 挂载数据: 无 ) 
│   │   │       ├── 将运维工程师融入服务团队 --> ( 难度等级: [0.2487, 0.2488) || 挂载数据: 无 ) 
│   │   │       ├── 为每个服务团队分派运维联络人 --> ( 难度等级: [0.2488, 0.2489) || 挂载数据: 无 ) 
│   │   │       └── 邀请运维工程师参加开发团队的会议 --> ( 难度等级: [0.2489, 0.249) || 挂载数据: 无 ) 
│   │   │           ├── 邀请运维工程师参加每日站会 --> ( 难度等级: [0.2489, 0.2489) || 挂载数据: blog: 10 ) 
│   │   │           ├── 邀请运维工程师参加回顾会议 --> ( 难度等级: [0.2489, 0.249) || 挂载数据: 无 ) 
│   │   │           └── 使用看板图展示运维工作 --> ( 难度等级: [0.249, 0.249) || 挂载数据: blog: 2 ) 
│   │   ├── 第一步：流动的技术实践 --> ( 难度等级: [0.249, 0.251) || 挂载数据: 无 ) 
│   │   │   ├── 为部署流水线奠定基础 --> ( 难度等级: [0.249, 0.2494) || 挂载数据: 无 ) 
│   │   │   │   ├── 按需搭建开发环境、测试环境和生产环境 --> ( 难度等级: [0.249, 0.2491) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用统一的代码仓库 --> ( 难度等级: [0.2491, 0.2492) || 挂载数据: 无 ) 
│   │   │   │   ├── 使基础设施的重建更容易 --> ( 难度等级: [0.2492, 0.2493) || 挂载数据: 无 ) 
│   │   │   │   └── 运行在类生产环境里才算“完成” --> ( 难度等级: [0.2493, 0.2494) || 挂载数据: 无 ) 
│   │   │   ├── 实现快速可靠的自动化测试 --> ( 难度等级: [0.2494, 0.2498) || 挂载数据: 无 ) 
│   │   │   │   ├── 对代码和环境做持续构建、测试和集成 --> ( 难度等级: [0.2494, 0.2495) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建快速可靠的自动化测试套件 --> ( 难度等级: [0.2495, 0.2497) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在自动化测试中尽早发现错误 --> ( 难度等级: [0.2495, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 尽可能并行地快速执行测试 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 先编写自动化测试 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 尽量将手动测试自动化 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在测试套件中集成性能测试 --> ( 难度等级: [0.2496, 0.2497) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在测试套件中集成非功能性需求测试 --> ( 难度等级: [0.2497, 0.2497) || 挂载数据: 无 ) 
│   │   │   │   └── 在部署流水线失败时拉下安灯绳 --> ( 难度等级: [0.2497, 0.2498) || 挂载数据: 无 ) 
│   │   │   ├── 应用和实践持续集成 --> ( 难度等级: [0.2498, 0.2502) || 挂载数据: 无 ) 
│   │   │   │   ├── 小批量开发与大批量合并 --> ( 难度等级: [0.2498, 0.25) || 挂载数据: 无 ) 
│   │   │   │   └── 应用基于主干的开发实践 --> ( 难度等级: [0.25, 0.2502) || 挂载数据: blog: 3 ) 
│   │   │   ├── 自动化和低风险发布 --> ( 难度等级: [0.2502, 0.2506) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化部署流程 --> ( 难度等级: [0.2502, 0.2504) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 应用自动化的自助式部署 --> ( 难度等级: [0.2502, 0.2503) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在部署流水线中集成代码部署 --> ( 难度等级: [0.2503, 0.2504) || 挂载数据: 无 ) 
│   │   │   │   └── 将部署与发布解耦 --> ( 难度等级: [0.2504, 0.2506) || 挂载数据: 无 ) 
│   │   │   │       ├── 基于环境的发布模式 --> ( 难度等级: [0.2504, 0.2505) || 挂载数据: 无 ) 
│   │   │   │       └── 基于应用的发布模式更安全 --> ( 难度等级: [0.2505, 0.2506) || 挂载数据: 无 ) 
│   │   │   └── 降低发布风险的架构 --> ( 难度等级: [0.2506, 0.251) || 挂载数据: 无 ) 
│   │   │       ├── 能提高生产力、可测试性和安全性的架构 --> ( 难度等级: [0.2506, 0.2507) || 挂载数据: 无 ) 
│   │   │       ├── 架构原型：单体架构与微服务 --> ( 难度等级: [0.2507, 0.2508) || 挂载数据: 无 ) 
│   │   │       └── 安全地演进企业架构 --> ( 难度等级: [0.2508, 0.251) || 挂载数据: blog: 1 ) 
│   │   ├── 第二步：反馈的技术实践 --> ( 难度等级: [0.251, 0.2529) || 挂载数据: 无 ) 
│   │   │   ├── 分析遥测数据以更好地预测故障和实现目标 --> ( 难度等级: [0.251, 0.2515) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常状态的处理和告警 --> ( 难度等级: [0.251, 0.2512) || 挂载数据: 无 ) 
│   │   │   │   └── 应用异常检测技术 --> ( 难度等级: [0.2512, 0.2515) || 挂载数据: 无 ) 
│   │   │   ├── 应用反馈实现安全部署 --> ( 难度等级: [0.2515, 0.252) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过遥测使部署更安全 --> ( 难度等级: [0.2515, 0.2516) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发和运维共同承担值班工作 --> ( 难度等级: [0.2516, 0.2517) || 挂载数据: 无 ) 
│   │   │   │   ├── 让开发人员跟踪工作对下游的影响 --> ( 难度等级: [0.2517, 0.2518) || 挂载数据: 无 ) 
│   │   │   │   └── 让开发人员自行管理生产服务 --> ( 难度等级: [0.2518, 0.252) || 挂载数据: 无 ) 
│   │   │   ├── 将假设驱动的开发和A/B测试融入日常工作 --> ( 难度等级: [0.252, 0.2525) || 挂载数据: 无 ) 
│   │   │   │   ├── A/B测试简史 --> ( 难度等级: [0.252, 0.2521) || 挂载数据: 无 ) 
│   │   │   │   ├── 在功能测试中集成A/B测试 --> ( 难度等级: [0.2521, 0.2522) || 挂载数据: 无 ) 
│   │   │   │   ├── 在发布中集成A/B测试 --> ( 难度等级: [0.2522, 0.2523) || 挂载数据: 无 ) 
│   │   │   │   └── 在功能规划中集成A/B测试 --> ( 难度等级: [0.2523, 0.2525) || 挂载数据: 无 ) 
│   │   │   └── 建立评审和协作流程以提升当前工作的质量 --> ( 难度等级: [0.2525, 0.2529) || 挂载数据: 无 ) 
│   │   │       ├── 变更审批流程的危险 --> ( 难度等级: [0.2525, 0.2525) || 挂载数据: 无 ) 
│   │   │       ├── “过度控制变更”的潜在危险 --> ( 难度等级: [0.2525, 0.2526) || 挂载数据: 无 ) 
│   │   │       ├── 变更的协调和排程 --> ( 难度等级: [0.2526, 0.2527) || 挂载数据: 无 ) 
│   │   │       ├── 变更的同行评审 --> ( 难度等级: [0.2527, 0.2527) || 挂载数据: 无 ) 
│   │   │       ├── 人工测试和变更冻结的潜在危害 --> ( 难度等级: [0.2527, 0.2528) || 挂载数据: 无 ) 
│   │   │       ├── 利用结对编程改进代码变更 --> ( 难度等级: [0.2528, 0.2529) || 挂载数据: 无 ) 
│   │   │       └── 消除官僚流程 --> ( 难度等级: [0.2529, 0.2529) || 挂载数据: 无 ) 
│   │   ├── 集成信息安全、变更管理和合规性的技术实践 --> ( 难度等级: [0.2529, 0.2549) || 挂载数据: 无 ) 
│   │   │   ├── 将信息安全融入每个人的日常工作 --> ( 难度等级: [0.2529, 0.2539) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到开发迭代的演示中 --> ( 难度等级: [0.2529, 0.253) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到缺陷跟踪和事后分析会议中 --> ( 难度等级: [0.253, 0.2531) || 挂载数据: 无 ) 
│   │   │   │   ├── 将预防性安全控制集成到共享源代码库及共享服务中 --> ( 难度等级: [0.2531, 0.2532) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到部署流水线中 --> ( 难度等级: [0.2532, 0.2533) || 挂载数据: 无 ) 
│   │   │   │   ├── 保证应用程序的安全性 --> ( 难度等级: [0.2533, 0.2534) || 挂载数据: 无 ) 
│   │   │   │   ├── 确保软件供应链的安全 --> ( 难度等级: [0.2534, 0.2535) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 确保环境的安全 --> ( 难度等级: [0.2535, 0.2536) || 挂载数据: 无 ) 
│   │   │   │   ├── 将信息安全集成到生产环境遥测中 --> ( 难度等级: [0.2536, 0.2537) || 挂载数据: 无 ) 
│   │   │   │   ├── 在应用程序中建立安全遥测系统 --> ( 难度等级: [0.2537, 0.2537) || 挂载数据: 无 ) 
│   │   │   │   ├── 在环境中建立安全遥测系统 --> ( 难度等级: [0.2537, 0.2538) || 挂载数据: 无 ) 
│   │   │   │   └── 保护部署流水线 --> ( 难度等级: [0.2538, 0.2539) || 挂载数据: 无 ) 
│   │   │   └── 保护部署流水线 --> ( 难度等级: [0.2539, 0.2549) || 挂载数据: 无 ) 
│   │   │       ├── 将安全和合规性集成到变更批准流程中 --> ( 难度等级: [0.2539, 0.2541) || 挂载数据: 无 ) 
│   │   │       ├── 将大量低风险变更重新归类为标准变更 --> ( 难度等级: [0.2541, 0.2543) || 挂载数据: 无 ) 
│   │   │       ├── 如何处理常规变更 --> ( 难度等级: [0.2543, 0.2545) || 挂载数据: 无 ) 
│   │   │       ├── 减少对职责分离的依赖 --> ( 难度等级: [0.2545, 0.2547) || 挂载数据: 无 ) 
│   │   │       └── 确保为审计人员和合规人员留存文档和证据 --> ( 难度等级: [0.2547, 0.2549) || 挂载数据: 无 ) 
│   │   ├── Shell脚本在DevOps下的应用 --> ( 难度等级: [0.2549, 0.2569) || 挂载数据: 无 ) 
│   │   │   ├── Shell编程基础 --> ( 难度等级: [0.2549, 0.2552) || 挂载数据: 无 ) 
│   │   │   │   ├── Shell脚本的基本元素 --> ( 难度等级: [0.2549, 0.255) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Shell基础正则表达式 --> ( 难度等级: [0.255, 0.2551) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Shell特殊字符 --> ( 难度等级: [0.2551, 0.2551) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 变量和运算符 --> ( 难度等级: [0.2551, 0.2552) || 挂载数据: 无 ) 
│   │   │   ├── Shell中的控制流结构 --> ( 难度等级: [0.2552, 0.2556) || 挂载数据: 无 ) 
│   │   │   ├── sed的基础用法及实用举例 --> ( 难度等级: [0.2556, 0.2559) || 挂载数据: 无 ) 
│   │   │   │   ├── sed的基础语法格式 --> ( 难度等级: [0.2556, 0.2557) || 挂载数据: 无 ) 
│   │   │   │   └── sed的用法举例说明 --> ( 难度等级: [0.2557, 0.2559) || 挂载数据: blog: 2 ) 
│   │   │   ├── awk的基础用法及实用案例 --> ( 难度等级: [0.2559, 0.2562) || 挂载数据: 无 ) 
│   │   │   ├── Shell应用于DevOps开发中应掌握的系统知识点 --> ( 难度等级: [0.2562, 0.2565) || 挂载数据: blog: 5 ) 
│   │   │   └── 生产环境下的Shell脚本 --> ( 难度等级: [0.2565, 0.2569) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的备份类脚本 --> ( 难度等级: [0.2565, 0.2566) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的统计类脚本 --> ( 难度等级: [0.2566, 0.2567) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的监控类脚本 --> ( 难度等级: [0.2567, 0.2568) || 挂载数据: 无 ) 
│   │   │       └── 生产环境下的运维开发类脚本 --> ( 难度等级: [0.2568, 0.2569) || 挂载数据: blog: 1 ) 
│   │   ├── Python在DevOps与自动化运维中的应用 --> ( 难度等级: [0.2569, 0.2588) || 挂载数据: 无 ) 
│   │   │   ├── Python语言的应用领域 --> ( 难度等级: [0.2569, 0.2571) || 挂载数据: 无 ) 
│   │   │   ├── 选择Python的原因 --> ( 难度等级: [0.2571, 0.2574) || 挂载数据: 无 ) 
│   │   │   ├── Python的版本说明 --> ( 难度等级: [0.2574, 0.2576) || 挂载数据: 无 ) 
│   │   │   ├── Python基础学习工具 --> ( 难度等级: [0.2576, 0.2578) || 挂载数据: 无 ) 
│   │   │   │   ├── Python(x,y)简单介绍 --> ( 难度等级: [0.2576, 0.2577) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── IPython详细介绍 --> ( 难度等级: [0.2577, 0.2578) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Sublime Text3简单介绍 --> ( 难度等级: [0.2578, 0.2578) || 挂载数据: 无 ) 
│   │   │   ├── Python基础知识进阶 --> ( 难度等级: [0.2578, 0.2581) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则表达式应用 --> ( 难度等级: [0.2578, 0.2579) || 挂载数据: 无 ) 
│   │   │   │   ├── Python程序构成 --> ( 难度等级: [0.2579, 0.2579) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 使用Python解析JSON --> ( 难度等级: [0.2579, 0.2579) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Python异常处理与程序调试 --> ( 难度等级: [0.2579, 0.258) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Python函数 --> ( 难度等级: [0.258, 0.258) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Python面向对象 --> ( 难度等级: [0.258, 0.258) || 挂载数据: 无 ) 
│   │   │   │   ├── Python多进程 --> ( 难度等级: [0.258, 0.2581) || 挂载数据: 无 ) 
│   │   │   │   └── Python多线程 --> ( 难度等级: [0.2581, 0.2581) || 挂载数据: blog: 3 ) 
│   │   │   ├── Python经常用到的第三方类库 --> ( 难度等级: [0.2581, 0.2583) || 挂载数据: 无 ) 
│   │   │   ├── 利用Flask设计后端Restful API --> ( 难度等级: [0.2583, 0.2586) || 挂载数据: blog: 1 ) 
│   │   │   └── 工作中的Python脚本分享 --> ( 难度等级: [0.2586, 0.2588) || 挂载数据: 无 ) 
│   │   ├── Vagrant在DevOps环境中的应用 --> ( 难度等级: [0.2588, 0.2608) || 挂载数据: 无 ) 
│   │   │   ├── Vagrant简单介绍 --> ( 难度等级: [0.2588, 0.2592) || 挂载数据: 无 ) 
│   │   │   ├── Vagrant安装 --> ( 难度等级: [0.2592, 0.2596) || 挂载数据: 无 ) 
│   │   │   ├── 使用Vagrant配置本地开发环境 --> ( 难度等级: [0.2596, 0.26) || 挂载数据: 无 ) 
│   │   │   │   ├── Vagrant的具体安装步骤 --> ( 难度等级: [0.2596, 0.2597) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Vagrant配置文件详解 --> ( 难度等级: [0.2597, 0.2599) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Vagrant常用命令详解 --> ( 难度等级: [0.2599, 0.26) || 挂载数据: blog: 10 ) 
│   │   │   ├── 使用Vagrant搭建DevOps开发环境 --> ( 难度等级: [0.26, 0.2604) || 挂载数据: blog: 10 ) 
│   │   │   └── 使用Vagrant搭建分布式环境 --> ( 难度等级: [0.2604, 0.2608) || 挂载数据: 无 ) 
│   │   ├── 自动化部署管理工具Ansible --> ( 难度等级: [0.2608, 0.2627) || 挂载数据: 无 ) 
│   │   │   ├── YAML介绍 --> ( 难度等级: [0.2608, 0.261) || 挂载数据: 无 ) 
│   │   │   ├── Ansible的安装和配置 --> ( 难度等级: [0.261, 0.2611) || 挂载数据: 无 ) 
│   │   │   ├── 定义主机与组规则（Inventory） --> ( 难度等级: [0.2611, 0.2613) || 挂载数据: 无 ) 
│   │   │   ├── Ansible常用模块介绍 --> ( 难度等级: [0.2613, 0.2615) || 挂载数据: blog: 5 ) 
│   │   │   ├── playbook介绍 --> ( 难度等级: [0.2615, 0.2617) || 挂载数据: 无 ) 
│   │   │   ├── Ansible在AWS云平台中的应用 --> ( 难度等级: [0.2617, 0.2619) || 挂载数据: blog: 3 ) 
│   │   │   ├── 角色 --> ( 难度等级: [0.2619, 0.262) || 挂载数据: 无 ) 
│   │   │   ├── Jinja2过滤器 --> ( 难度等级: [0.262, 0.2622) || 挂载数据: 无 ) 
│   │   │   ├── Ansible速度优化 --> ( 难度等级: [0.2622, 0.2624) || 挂载数据: 无 ) 
│   │   │   ├── 利用Ansible API提供自动化运维后端 --> ( 难度等级: [0.2624, 0.2626) || 挂载数据: 无 ) 
│   │   │   │   ├── runner API --> ( 难度等级: [0.2624, 0.2624) || 挂载数据: 无 ) 
│   │   │   │   ├── playbook API --> ( 难度等级: [0.2624, 0.2625) || 挂载数据: 无 ) 
│   │   │   │   └── 用Flask封装Ansible提供自动化运维后端 --> ( 难度等级: [0.2625, 0.2626) || 挂载数据: blog: 10 ) 
│   │   │   └── Ansible 2.2新增功能 --> ( 难度等级: [0.2626, 0.2627) || 挂载数据: 无 ) 
│   │   ├── 自动化配置管理工具SaltStack --> ( 难度等级: [0.2627, 0.2647) || 挂载数据: 无 ) 
│   │   │   ├── Salt的相关知识点介绍 --> ( 难度等级: [0.2627, 0.2631) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的优势 --> ( 难度等级: [0.2627, 0.2628) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的安装 --> ( 难度等级: [0.2628, 0.2629) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的工作流程 --> ( 难度等级: [0.2629, 0.263) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Salt配置文件详解 --> ( 难度等级: [0.263, 0.2631) || 挂载数据: 无 ) 
│   │   │   │   └── Salt的命令格式 --> ( 难度等级: [0.2631, 0.2631) || 挂载数据: blog: 1 ) 
│   │   │   ├── Salt的常用组件 --> ( 难度等级: [0.2631, 0.2635) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt常用的操作目标 --> ( 难度等级: [0.2631, 0.2632) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt常用模块 --> ( 难度等级: [0.2632, 0.2633) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Granis组件 --> ( 难度等级: [0.2633, 0.2633) || 挂载数据: 无 ) 
│   │   │   │   ├── pillar组件 --> ( 难度等级: [0.2633, 0.2634) || 挂载数据: 无 ) 
│   │   │   │   ├── job管理 --> ( 难度等级: [0.2634, 0.2635) || 挂载数据: 无 ) 
│   │   │   │   └── State介绍 --> ( 难度等级: [0.2635, 0.2635) || 挂载数据: 无 ) 
│   │   │   ├── Salt真实案例分享 --> ( 难度等级: [0.2635, 0.2639) || 挂载数据: 无 ) 
│   │   │   │   ├── base环境配置 --> ( 难度等级: [0.2635, 0.2637) || 挂载数据: 无 ) 
│   │   │   │   └── prod环境配置 --> ( 难度等级: [0.2637, 0.2639) || 挂载数据: 无 ) 
│   │   │   ├── Salt多Master搭建 --> ( 难度等级: [0.2639, 0.2643) || 挂载数据: 无 ) 
│   │   │   └── Salt API介绍 --> ( 难度等级: [0.2643, 0.2647) || 挂载数据: 无 ) 
│   │   │       ├── Python API介绍 --> ( 难度等级: [0.2643, 0.2645) || 挂载数据: blog: 4 ) 
│   │   │       └── Restful API介绍 --> ( 难度等级: [0.2645, 0.2647) || 挂载数据: blog: 1 ) 
│   │   └── Docker和Jenkins在DevOps中的应用 --> ( 难度等级: [0.2647, 0.2667) || 挂载数据: 无 ) 
│   │       ├── Docker的基础安装 --> ( 难度等级: [0.2647, 0.265) || 挂载数据: 无 ) 
│   │       ├── Docker的三大核心概念 --> ( 难度等级: [0.265, 0.2653) || 挂载数据: 无 ) 
│   │       ├── Docker的基本架构 --> ( 难度等级: [0.2653, 0.2655) || 挂载数据: 无 ) 
│   │       ├── Docker网络实现原理 --> ( 难度等级: [0.2655, 0.2658) || 挂载数据: 无 ) 
│   │       ├── 利用Dockerfile文件技巧打包Docker镜像 --> ( 难度等级: [0.2658, 0.2661) || 挂载数据: 无 ) 
│   │       ├── 利用Docker-Compose编排和管理多容器 --> ( 难度等级: [0.2661, 0.2664) || 挂载数据: 无 ) 
│   │       │   ├── Docker-Compose的基本语法 --> ( 难度等级: [0.2661, 0.2662) || 挂载数据: 无 ) 
│   │       │   └── Docker-Compose常用命令 --> ( 难度等级: [0.2662, 0.2664) || 挂载数据: blog: 10 ) 
│   │       └── 利用Docker搭建Jenkins Master/Slave分布式环境 --> ( 难度等级: [0.2664, 0.2667) || 挂载数据: 无 ) 
│   │           └── Jenkins Master/Slave的详细部署过程 --> ( 难度等级: [0.2664, 0.2667) || 挂载数据: blog: 10 ) 
│   ├── 中间件 --> ( 难度等级: [0.2667, 0.3) || 挂载数据: 无 ) 
│   │   ├── 缓存 --> ( 难度等级: [0.2667, 0.2778) || 挂载数据: 无 ) 
│   │   │   ├── etcd --> ( 难度等级: [0.2667, 0.2722) || 挂载数据: 无 ) 
│   │   │   └── Redis --> ( 难度等级: [0.2722, 0.2778) || 挂载数据: 无 ) 
│   │   ├── 微服务与配置中心 --> ( 难度等级: [0.2778, 0.2889) || 挂载数据: 无 ) 
│   │   │   └── Nacos --> ( 难度等级: [0.2778, 0.2889) || 挂载数据: blog: 10 ) 
│   │   └── 存储 --> ( 难度等级: [0.2889, 0.3) || 挂载数据: 无 ) 
│   │       ├── S3标准 --> ( 难度等级: [0.2889, 0.2926) || 挂载数据: 无 ) 
│   │       ├── MinIO --> ( 难度等级: [0.2926, 0.2963) || 挂载数据: blog: 4 ) 
│   │       └── Harbor --> ( 难度等级: [0.2963, 0.3) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.3, 0.3333) || 挂载数据: 无 ) 
├── 云原生中阶-应用开发 --> ( 难度等级: [0.3333, 0.5) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.3333, 0.3889) || 挂载数据: 无 ) 
│   │   └── App Serverless --> ( 难度等级: [0.3333, 0.3889) || 挂载数据: 无 ) 
│   │       └── Knative --> ( 难度等级: [0.3333, 0.3889) || 挂载数据: 无 ) 
│   ├── Microservices微服务 --> ( 难度等级: [0.3889, 0.4444) || 挂载数据: 无 ) 
│   │   └── Dapr --> ( 难度等级: [0.3889, 0.4444) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.4444, 0.5) || 挂载数据: 无 ) 
├── 云原生中阶-平台开发 --> ( 难度等级: [0.5, 0.6667) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.5, 0.5417) || 挂载数据: 无 ) 
│   │   ├── 边缘计算 --> ( 难度等级: [0.5, 0.5013) || 挂载数据: 无 ) 
│   │   │   ├── OpenYurt --> ( 难度等级: [0.5, 0.5004) || 挂载数据: 无 ) 
│   │   │   ├── KubeEdge --> ( 难度等级: [0.5004, 0.5009) || 挂载数据: blog: 1 ) 
│   │   │   └── Akri --> ( 难度等级: [0.5009, 0.5013) || 挂载数据: 无 ) 
│   │   ├── 集群联邦 --> ( 难度等级: [0.5013, 0.5027) || 挂载数据: 无 ) 
│   │   │   └── Federation --> ( 难度等级: [0.5013, 0.5027) || 挂载数据: 无 ) 
│   │   ├── 发行版 --> ( 难度等级: [0.5027, 0.504) || 挂载数据: 无 ) 
│   │   │   ├── EKS-D --> ( 难度等级: [0.5027, 0.503) || 挂载数据: 无 ) 
│   │   │   ├── Harvester --> ( 难度等级: [0.503, 0.5032) || 挂载数据: 无 ) 
│   │   │   ├── OpenShift --> ( 难度等级: [0.5032, 0.5035) || 挂载数据: blog: 4 ) 
│   │   │   ├── k0s --> ( 难度等级: [0.5035, 0.5038) || 挂载数据: 无 ) 
│   │   │   └── Wayne --> ( 难度等级: [0.5038, 0.504) || 挂载数据: 无 ) 
│   │   ├── Kubernetes系统基础 --> ( 难度等级: [0.504, 0.5054) || 挂载数据: 无 ) 
│   │   │   ├── 容器技术概述 --> ( 难度等级: [0.504, 0.5044) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器技术的功用 --> ( 难度等级: [0.504, 0.5041) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 容器简史 --> ( 难度等级: [0.5041, 0.5043) || 挂载数据: 无 ) 
│   │   │   │   └── Docker的功能限制 --> ( 难度等级: [0.5043, 0.5044) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes概述 --> ( 难度等级: [0.5044, 0.5047) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes简史 --> ( 难度等级: [0.5044, 0.5045) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes特性 --> ( 难度等级: [0.5045, 0.5046) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Kubernetes概念和术语 --> ( 难度等级: [0.5046, 0.5047) || 挂载数据: blog: 5 ) 
│   │   │   ├── Kubernetes集群组件 --> ( 难度等级: [0.5047, 0.505) || 挂载数据: 无 ) 
│   │   │   │   ├── Master组件 --> ( 难度等级: [0.5047, 0.5048) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Node组件 --> ( 难度等级: [0.5048, 0.5049) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 核心附件 --> ( 难度等级: [0.5049, 0.505) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes网络模型基础 --> ( 难度等级: [0.505, 0.5054) || 挂载数据: 无 ) 
│   │   │       ├── 网络模型概述 --> ( 难度等级: [0.505, 0.5052) || 挂载数据: 无 ) 
│   │   │       └── 集群上的网络通信 --> ( 难度等级: [0.5052, 0.5054) || 挂载数据: 无 ) 
│   │   ├── Kubernetes快速入门 --> ( 难度等级: [0.5054, 0.5067) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes的核心对象 --> ( 难度等级: [0.5054, 0.5057) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod资源对象 --> ( 难度等级: [0.5054, 0.5055) || 挂载数据: 无 ) 
│   │   │   │   ├── Controller --> ( 难度等级: [0.5055, 0.5055) || 挂载数据: 无 ) 
│   │   │   │   ├── Service --> ( 难度等级: [0.5055, 0.5056) || 挂载数据: 无 ) 
│   │   │   │   └── 部署应用程序的主体过程 --> ( 难度等级: [0.5056, 0.5057) || 挂载数据: 无 ) 
│   │   │   ├── 部署Kubernetes集群 --> ( 难度等级: [0.5057, 0.506) || 挂载数据: 无 ) 
│   │   │   │   ├── kubeadm部署工具 --> ( 难度等级: [0.5057, 0.5058) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 集群运行模式 --> ( 难度等级: [0.5058, 0.5059) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 准备用于实践操作的集群环境 --> ( 难度等级: [0.5059, 0.506) || 挂载数据: 无 ) 
│   │   │   │   └── 获取集群环境相关的信息 --> ( 难度等级: [0.506, 0.506) || 挂载数据: 无 ) 
│   │   │   ├── kubectl使用基础与示例 --> ( 难度等级: [0.506, 0.5064) || 挂载数据: 无 ) 
│   │   │   └── 命令式容器应用编排 --> ( 难度等级: [0.5064, 0.5067) || 挂载数据: 无 ) 
│   │   │       ├── 部署应用（Pod） --> ( 难度等级: [0.5064, 0.5065) || 挂载数据: 无 ) 
│   │   │       ├── 探查Pod及应用详情 --> ( 难度等级: [0.5065, 0.5065) || 挂载数据: 无 ) 
│   │   │       ├── 部署Service对象 --> ( 难度等级: [0.5065, 0.5066) || 挂载数据: 无 ) 
│   │   │       ├── 扩容和缩容 --> ( 难度等级: [0.5066, 0.5067) || 挂载数据: 无 ) 
│   │   │       └── 修改及删除对象 --> ( 难度等级: [0.5067, 0.5067) || 挂载数据: 无 ) 
│   │   ├── 资源管理基础 --> ( 难度等级: [0.5067, 0.5081) || 挂载数据: 无 ) 
│   │   │   ├── 资源对象及API群组 --> ( 难度等级: [0.5067, 0.507) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的资源对象 --> ( 难度等级: [0.5067, 0.5068) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源及其在API中的组织形式 --> ( 难度等级: [0.5068, 0.5069) || 挂载数据: 无 ) 
│   │   │   │   └── 访问Kubernetes REST API --> ( 难度等级: [0.5069, 0.507) || 挂载数据: 无 ) 
│   │   │   ├── 对象类资源格式 --> ( 难度等级: [0.507, 0.5073) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源配置清单 --> ( 难度等级: [0.507, 0.507) || 挂载数据: 无 ) 
│   │   │   │   ├── metadata嵌套字段 --> ( 难度等级: [0.507, 0.5071) || 挂载数据: 无 ) 
│   │   │   │   ├── spec和status字段 --> ( 难度等级: [0.5071, 0.5072) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源配置清单格式文档 --> ( 难度等级: [0.5072, 0.5072) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 资源对象管理方式 --> ( 难度等级: [0.5072, 0.5073) || 挂载数据: 无 ) 
│   │   │   ├── kubectl命令与资源管理 --> ( 难度等级: [0.5073, 0.5075) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源管理操作概述 --> ( 难度等级: [0.5073, 0.5074) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl的基本用法 --> ( 难度等级: [0.5074, 0.5075) || 挂载数据: 无 ) 
│   │   │   ├── 管理名称空间资源 --> ( 难度等级: [0.5075, 0.5078) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看名称空间及其资源对象 --> ( 难度等级: [0.5075, 0.5077) || 挂载数据: 无 ) 
│   │   │   │   └── 管理Namespace资源 --> ( 难度等级: [0.5077, 0.5078) || 挂载数据: 无 ) 
│   │   │   └── Pod资源的基础管理操作 --> ( 难度等级: [0.5078, 0.5081) || 挂载数据: 无 ) 
│   │   │       ├── 陈述式对象配置管理方式 --> ( 难度等级: [0.5078, 0.5079) || 挂载数据: 无 ) 
│   │   │       └── 声明式对象配置管理方式 --> ( 难度等级: [0.5079, 0.5081) || 挂载数据: 无 ) 
│   │   ├── 管理Pod资源对象 --> ( 难度等级: [0.5081, 0.5094) || 挂载数据: 无 ) 
│   │   │   ├── 管理Pod对象的容器 --> ( 难度等级: [0.5081, 0.5083) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像及其获取策略 --> ( 难度等级: [0.5081, 0.5081) || 挂载数据: 无 ) 
│   │   │   │   ├── 暴露端口 --> ( 难度等级: [0.5081, 0.5081) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义运行的容器化应用 --> ( 难度等级: [0.5081, 0.5082) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 环境变量 --> ( 难度等级: [0.5082, 0.5082) || 挂载数据: 无 ) 
│   │   │   │   ├── 共享节点的网络名称空间 --> ( 难度等级: [0.5082, 0.5082) || 挂载数据: 无 ) 
│   │   │   │   └── 设置Pod对象的安全上下文 --> ( 难度等级: [0.5082, 0.5083) || 挂载数据: blog: 2 ) 
│   │   │   ├── 标签与标签选择器 --> ( 难度等级: [0.5083, 0.5084) || 挂载数据: 无 ) 
│   │   │   │   ├── 标签概述 --> ( 难度等级: [0.5083, 0.5083) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 管理资源标签 --> ( 难度等级: [0.5083, 0.5084) || 挂载数据: 无 ) 
│   │   │   │   ├── 标签选择器 --> ( 难度等级: [0.5084, 0.5084) || 挂载数据: 无 ) 
│   │   │   │   └── Pod节点选择器nodeSelector --> ( 难度等级: [0.5084, 0.5084) || 挂载数据: 无 ) 
│   │   │   ├── 资源注解 --> ( 难度等级: [0.5084, 0.5086) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看资源注解 --> ( 难度等级: [0.5084, 0.5085) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 管理资源注解 --> ( 难度等级: [0.5085, 0.5086) || 挂载数据: 无 ) 
│   │   │   ├── Pod对象的生命周期 --> ( 难度等级: [0.5086, 0.5088) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的相位 --> ( 难度等级: [0.5086, 0.5087) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的创建过程 --> ( 难度等级: [0.5087, 0.5087) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod生命周期中的重要行为 --> ( 难度等级: [0.5087, 0.5088) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器的重启策略 --> ( 难度等级: [0.5088, 0.5088) || 挂载数据: 无 ) 
│   │   │   │   └── Pod的终止过程 --> ( 难度等级: [0.5088, 0.5088) || 挂载数据: 无 ) 
│   │   │   ├── Pod存活性探测 --> ( 难度等级: [0.5088, 0.509) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置exec探针 --> ( 难度等级: [0.5088, 0.5089) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 设置HTTP探针 --> ( 难度等级: [0.5089, 0.5089) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置TCP探针 --> ( 难度等级: [0.5089, 0.509) || 挂载数据: 无 ) 
│   │   │   │   └── 存活性探测行为属性 --> ( 难度等级: [0.509, 0.509) || 挂载数据: 无 ) 
│   │   │   ├── Pod就绪性探测 --> ( 难度等级: [0.509, 0.5092) || 挂载数据: 无 ) 
│   │   │   └── 资源需求及资源限制 --> ( 难度等级: [0.5092, 0.5094) || 挂载数据: 无 ) 
│   │   │       ├── 资源需求 --> ( 难度等级: [0.5092, 0.5093) || 挂载数据: 无 ) 
│   │   │       ├── 资源限制 --> ( 难度等级: [0.5093, 0.5093) || 挂载数据: blog: 1 ) 
│   │   │       ├── 容器的可见资源 --> ( 难度等级: [0.5093, 0.5094) || 挂载数据: blog: 2 ) 
│   │   │       └── Pod的服务质量类别 --> ( 难度等级: [0.5094, 0.5094) || 挂载数据: 无 ) 
│   │   ├── Pod控制器 --> ( 难度等级: [0.5094, 0.5108) || 挂载数据: 无 ) 
│   │   │   ├── 关于Pod控制器 --> ( 难度等级: [0.5094, 0.5096) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod控制器概述 --> ( 难度等级: [0.5094, 0.5095) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 控制器与Pod对象 --> ( 难度等级: [0.5095, 0.5095) || 挂载数据: 无 ) 
│   │   │   │   └── Pod模板资源 --> ( 难度等级: [0.5095, 0.5096) || 挂载数据: 无 ) 
│   │   │   ├── ReplicaSet控制器 --> ( 难度等级: [0.5096, 0.5097) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet概述 --> ( 难度等级: [0.5096, 0.5096) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建ReplicaSet --> ( 难度等级: [0.5096, 0.5096) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet管控下的Pod对象 --> ( 难度等级: [0.5096, 0.5097) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新ReplicaSet控制器 --> ( 难度等级: [0.5097, 0.5097) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 删除ReplicaSet控制器资源 --> ( 难度等级: [0.5097, 0.5097) || 挂载数据: blog: 1 ) 
│   │   │   ├── Deployment控制器 --> ( 难度等级: [0.5097, 0.5099) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Deployment --> ( 难度等级: [0.5097, 0.5098) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新策略 --> ( 难度等级: [0.5098, 0.5098) || 挂载数据: 无 ) 
│   │   │   │   ├── 升级Deployment --> ( 难度等级: [0.5098, 0.5098) || 挂载数据: 无 ) 
│   │   │   │   ├── 金丝雀发布 --> ( 难度等级: [0.5098, 0.5099) || 挂载数据: 无 ) 
│   │   │   │   └── 回滚Deployment控制器下的应用发布 --> ( 难度等级: [0.5099, 0.5099) || 挂载数据: 无 ) 
│   │   │   ├── DaemonSet控制器 --> ( 难度等级: [0.5099, 0.5101) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建DaemonSet资源对象 --> ( 难度等级: [0.5099, 0.51) || 挂载数据: 无 ) 
│   │   │   │   └── 更新DaemonSet对象 --> ( 难度等级: [0.51, 0.5101) || 挂载数据: 无 ) 
│   │   │   ├── Job控制器 --> ( 难度等级: [0.5101, 0.5102) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Job对象 --> ( 难度等级: [0.5101, 0.5101) || 挂载数据: 无 ) 
│   │   │   │   ├── 并行式Job --> ( 难度等级: [0.5101, 0.5102) || 挂载数据: 无 ) 
│   │   │   │   ├── Job扩容 --> ( 难度等级: [0.5102, 0.5102) || 挂载数据: 无 ) 
│   │   │   │   └── 删除Job --> ( 难度等级: [0.5102, 0.5102) || 挂载数据: 无 ) 
│   │   │   ├── CronJob控制器 --> ( 难度等级: [0.5102, 0.5104) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建CronJob对象 --> ( 难度等级: [0.5102, 0.5103) || 挂载数据: 无 ) 
│   │   │   │   └── CronJob的控制机制 --> ( 难度等级: [0.5103, 0.5104) || 挂载数据: blog: 10 ) 
│   │   │   ├── ReplicationController --> ( 难度等级: [0.5104, 0.5106) || 挂载数据: 无 ) 
│   │   │   └── Pod中断预算 --> ( 难度等级: [0.5106, 0.5108) || 挂载数据: 无 ) 
│   │   ├── 存储卷与数据持久化 --> ( 难度等级: [0.5108, 0.5121) || 挂载数据: 无 ) 
│   │   │   ├── 存储卷概述 --> ( 难度等级: [0.5108, 0.511) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes支持的存储卷类型 --> ( 难度等级: [0.5108, 0.5109) || 挂载数据: 无 ) 
│   │   │   │   └── 存储卷的使用方式 --> ( 难度等级: [0.5109, 0.511) || 挂载数据: 无 ) 
│   │   │   ├── 临时存储卷 --> ( 难度等级: [0.511, 0.5112) || 挂载数据: 无 ) 
│   │   │   │   ├── emptyDir存储卷 --> ( 难度等级: [0.511, 0.5111) || 挂载数据: 无 ) 
│   │   │   │   └── gitRepo存储卷 --> ( 难度等级: [0.5111, 0.5112) || 挂载数据: 无 ) 
│   │   │   ├── 节点存储卷hostPath --> ( 难度等级: [0.5112, 0.5114) || 挂载数据: 无 ) 
│   │   │   ├── 网络存储卷 --> ( 难度等级: [0.5114, 0.5116) || 挂载数据: 无 ) 
│   │   │   │   ├── NFS存储卷 --> ( 难度等级: [0.5114, 0.5115) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── RBD存储卷 --> ( 难度等级: [0.5115, 0.5115) || 挂载数据: 无 ) 
│   │   │   │   ├── GlusterFS存储卷 --> ( 难度等级: [0.5115, 0.5116) || 挂载数据: 无 ) 
│   │   │   │   └── Cinder存储卷 --> ( 难度等级: [0.5116, 0.5116) || 挂载数据: blog: 1 ) 
│   │   │   ├── 持久存储卷 --> ( 难度等级: [0.5116, 0.5119) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建PV --> ( 难度等级: [0.5116, 0.5117) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建PVC --> ( 难度等级: [0.5117, 0.5117) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Pod中使用PVC --> ( 难度等级: [0.5117, 0.5118) || 挂载数据: 无 ) 
│   │   │   │   ├── 存储类 --> ( 难度等级: [0.5118, 0.5118) || 挂载数据: 无 ) 
│   │   │   │   └── PV和PVC的生命周期 --> ( 难度等级: [0.5118, 0.5119) || 挂载数据: 无 ) 
│   │   │   └── downwardAPI存储卷 --> ( 难度等级: [0.5119, 0.5121) || 挂载数据: 无 ) 
│   │   │       ├── 环境变量式元数据注入 --> ( 难度等级: [0.5119, 0.512) || 挂载数据: 无 ) 
│   │   │       └── 存储卷式元数据注入 --> ( 难度等级: [0.512, 0.5121) || 挂载数据: blog: 2 ) 
│   │   ├── 配置容器应用：ConfigMap和Secret --> ( 难度等级: [0.5121, 0.5134) || 挂载数据: 无 ) 
│   │   │   ├── 容器化应用配置方式 --> ( 难度等级: [0.5121, 0.5124) || 挂载数据: 无 ) 
│   │   │   ├── 通过命令行参数配置容器应用 --> ( 难度等级: [0.5124, 0.5126) || 挂载数据: 无 ) 
│   │   │   ├── 利用环境变量配置容器应用 --> ( 难度等级: [0.5126, 0.5129) || 挂载数据: 无 ) 
│   │   │   ├── 应用程序配置管理及ConfigMap资源 --> ( 难度等级: [0.5129, 0.5132) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建ConfigMap对象 --> ( 难度等级: [0.5129, 0.513) || 挂载数据: 无 ) 
│   │   │   │   ├── 向Pod环境变量传递ConfigMap对象键值数据 --> ( 难度等级: [0.513, 0.513) || 挂载数据: 无 ) 
│   │   │   │   ├── ConfigMap存储卷 --> ( 难度等级: [0.513, 0.5131) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器应用重载新配置 --> ( 难度等级: [0.5131, 0.5131) || 挂载数据: 无 ) 
│   │   │   │   └── 使用ConfigMap资源的注意事项 --> ( 难度等级: [0.5131, 0.5132) || 挂载数据: 无 ) 
│   │   │   └── Secret资源 --> ( 难度等级: [0.5132, 0.5134) || 挂载数据: 无 ) 
│   │   │       ├── Secret概述 --> ( 难度等级: [0.5132, 0.5132) || 挂载数据: 无 ) 
│   │   │       ├── 创建Secret资源 --> ( 难度等级: [0.5132, 0.5133) || 挂载数据: 无 ) 
│   │   │       ├── Secret存储卷 --> ( 难度等级: [0.5133, 0.5134) || 挂载数据: blog: 1 ) 
│   │   │       └── imagePullSecret资源对象 --> ( 难度等级: [0.5134, 0.5134) || 挂载数据: 无 ) 
│   │   ├── StatefulSet控制器 --> ( 难度等级: [0.5134, 0.5148) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet概述 --> ( 难度等级: [0.5134, 0.5137) || 挂载数据: 无 ) 
│   │   │   │   ├── Stateful应用和Stateless应用 --> ( 难度等级: [0.5134, 0.5135) || 挂载数据: 无 ) 
│   │   │   │   ├── StatefulSet控制器概述 --> ( 难度等级: [0.5135, 0.5136) || 挂载数据: 无 ) 
│   │   │   │   └── StatefulSet的特性 --> ( 难度等级: [0.5136, 0.5137) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet基础应用 --> ( 难度等级: [0.5137, 0.514) || 挂载数据: 无 ) 
│   │   │   │   └── 创建StatefulSet对象 --> ( 难度等级: [0.5137, 0.514) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet资源扩缩容 --> ( 难度等级: [0.514, 0.5142) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet资源升级 --> ( 难度等级: [0.5142, 0.5145) || 挂载数据: 无 ) 
│   │   │   │   ├── 滚动更新 --> ( 难度等级: [0.5142, 0.5143) || 挂载数据: 无 ) 
│   │   │   │   ├── 暂存更新操作 --> ( 难度等级: [0.5143, 0.5144) || 挂载数据: 无 ) 
│   │   │   │   ├── 金丝雀部署 --> ( 难度等级: [0.5144, 0.5144) || 挂载数据: 无 ) 
│   │   │   │   ├── 分段更新 --> ( 难度等级: [0.5144, 0.5145) || 挂载数据: 无 ) 
│   │   │   │   └── 其他话题 --> ( 难度等级: [0.5145, 0.5145) || 挂载数据: 无 ) 
│   │   │   └── 案例：etcd集群 --> ( 难度等级: [0.5145, 0.5148) || 挂载数据: 无 ) 
│   │   │       ├── 创建Service资源 --> ( 难度等级: [0.5145, 0.5147) || 挂载数据: 无 ) 
│   │   │       └── etcd StatefulSet --> ( 难度等级: [0.5147, 0.5148) || 挂载数据: blog: 10 ) 
│   │   ├── 认证、授权与准入控制 --> ( 难度等级: [0.5148, 0.5161) || 挂载数据: 无 ) 
│   │   │   ├── 访问控制概述 --> ( 难度等级: [0.5148, 0.5151) || 挂载数据: 无 ) 
│   │   │   │   ├── 用户账户与用户组 --> ( 难度等级: [0.5148, 0.5149) || 挂载数据: 无 ) 
│   │   │   │   └── 认证、授权与准入控制基础 --> ( 难度等级: [0.5149, 0.5151) || 挂载数据: blog: 1 ) 
│   │   │   ├── 服务账户管理与应用 --> ( 难度等级: [0.5151, 0.5153) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Account自动化 --> ( 难度等级: [0.5151, 0.5151) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建服务账户 --> ( 难度等级: [0.5151, 0.5152) || 挂载数据: 无 ) 
│   │   │   │   └── 调用imagePullSecret资源对象 --> ( 难度等级: [0.5152, 0.5153) || 挂载数据: 无 ) 
│   │   │   ├── X.509数字证书认证 --> ( 难度等级: [0.5153, 0.5156) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes中的SSL/TLS认证 --> ( 难度等级: [0.5153, 0.5154) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 客户端配置文件kubeconfig --> ( 难度等级: [0.5154, 0.5155) || 挂载数据: 无 ) 
│   │   │   │   └── TLS bootstrapping机制 --> ( 难度等级: [0.5155, 0.5156) || 挂载数据: 无 ) 
│   │   │   ├── 基于角色的访问控制：RBAC --> ( 难度等级: [0.5156, 0.5159) || 挂载数据: 无 ) 
│   │   │   │   ├── RBAC授权插件 --> ( 难度等级: [0.5156, 0.5156) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Role和RoleBinding --> ( 难度等级: [0.5156, 0.5157) || 挂载数据: 无 ) 
│   │   │   │   ├── ClusterRole和ClusterRoleBin-ding --> ( 难度等级: [0.5157, 0.5157) || 挂载数据: 无 ) 
│   │   │   │   ├── 聚合型ClusterRole --> ( 难度等级: [0.5157, 0.5158) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向用户的内建ClusterRole --> ( 难度等级: [0.5158, 0.5158) || 挂载数据: 无 ) 
│   │   │   │   └── 其他的内建ClusterRole和ClusterRoleBinding --> ( 难度等级: [0.5158, 0.5159) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes Dashboard --> ( 难度等级: [0.5159, 0.5161) || 挂载数据: 无 ) 
│   │   │       ├── 部署HTTPS通信的Dashboard --> ( 难度等级: [0.5159, 0.5159) || 挂载数据: blog: 10 ) 
│   │   │       ├── 配置token认证 --> ( 难度等级: [0.5159, 0.516) || 挂载数据: blog: 1 ) 
│   │   │       └── 配置kubeconfig认证 --> ( 难度等级: [0.516, 0.5161) || 挂载数据: 无 ) 
│   │   ├── 网络模型与网络策略 --> ( 难度等级: [0.5161, 0.5175) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络模型及CNI插件 --> ( 难度等级: [0.5161, 0.5165) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker容器的网络模型 --> ( 难度等级: [0.5161, 0.5162) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络模型 --> ( 难度等级: [0.5162, 0.5163) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Pod网络的实现方式 --> ( 难度等级: [0.5163, 0.5164) || 挂载数据: 无 ) 
│   │   │   │   └── CNI插件及其常见的实现 --> ( 难度等级: [0.5164, 0.5165) || 挂载数据: 无 ) 
│   │   │   ├── flannel网络插件 --> ( 难度等级: [0.5165, 0.5168) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel的配置参数 --> ( 难度等级: [0.5165, 0.5166) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── VxLAN后端和direct routing --> ( 难度等级: [0.5166, 0.5167) || 挂载数据: 无 ) 
│   │   │   │   └── host-gw后端 --> ( 难度等级: [0.5167, 0.5168) || 挂载数据: 无 ) 
│   │   │   ├── 网络策略 --> ( 难度等级: [0.5168, 0.5171) || 挂载数据: 无 ) 
│   │   │   │   ├── 网络策略概述 --> ( 难度等级: [0.5168, 0.5168) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Canal提供网络策略功能 --> ( 难度等级: [0.5168, 0.5169) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置网络策略 --> ( 难度等级: [0.5169, 0.5169) || 挂载数据: 无 ) 
│   │   │   │   ├── 管控入站流量 --> ( 难度等级: [0.5169, 0.517) || 挂载数据: 无 ) 
│   │   │   │   ├── 管控出站流量 --> ( 难度等级: [0.517, 0.517) || 挂载数据: 无 ) 
│   │   │   │   ├── 隔离名称空间 --> ( 难度等级: [0.517, 0.5171) || 挂载数据: 无 ) 
│   │   │   │   └── 网络策略应用案例 --> ( 难度等级: [0.5171, 0.5171) || 挂载数据: 无 ) 
│   │   │   └── Calico网络插件 --> ( 难度等级: [0.5171, 0.5175) || 挂载数据: 无 ) 
│   │   │       ├── Calico工作特性 --> ( 难度等级: [0.5171, 0.5172) || 挂载数据: 无 ) 
│   │   │       ├── Calico系统架构 --> ( 难度等级: [0.5172, 0.5173) || 挂载数据: 无 ) 
│   │   │       ├── Calico部署要点 --> ( 难度等级: [0.5173, 0.5173) || 挂载数据: blog: 1 ) 
│   │   │       ├── 部署Calico提供网络服务和网络策略 --> ( 难度等级: [0.5173, 0.5174) || 挂载数据: 无 ) 
│   │   │       └── 客户端工具calicoctl --> ( 难度等级: [0.5174, 0.5175) || 挂载数据: 无 ) 
│   │   ├── Pod资源调度 --> ( 难度等级: [0.5175, 0.5188) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes调度器概述 --> ( 难度等级: [0.5175, 0.5177) || 挂载数据: 无 ) 
│   │   │   │   ├── 常用的预选策略 --> ( 难度等级: [0.5175, 0.5176) || 挂载数据: 无 ) 
│   │   │   │   └── 常用的优选函数 --> ( 难度等级: [0.5176, 0.5177) || 挂载数据: 无 ) 
│   │   │   ├── 节点亲和调度 --> ( 难度等级: [0.5177, 0.518) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点硬亲和性 --> ( 难度等级: [0.5177, 0.5179) || 挂载数据: 无 ) 
│   │   │   │   └── 节点软亲和性 --> ( 难度等级: [0.5179, 0.518) || 挂载数据: 无 ) 
│   │   │   ├── Pod资源亲和调度 --> ( 难度等级: [0.518, 0.5183) || 挂载数据: 无 ) 
│   │   │   │   ├── 位置拓扑 --> ( 难度等级: [0.518, 0.5181) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod硬亲和调度 --> ( 难度等级: [0.5181, 0.5181) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod软亲和调度 --> ( 难度等级: [0.5181, 0.5182) || 挂载数据: 无 ) 
│   │   │   │   └── Pod反亲和调度 --> ( 难度等级: [0.5182, 0.5183) || 挂载数据: blog: 1 ) 
│   │   │   ├── 污点和容忍度 --> ( 难度等级: [0.5183, 0.5185) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义污点和容忍度 --> ( 难度等级: [0.5183, 0.5184) || 挂载数据: 无 ) 
│   │   │   │   ├── 管理节点的污点 --> ( 难度等级: [0.5184, 0.5185) || 挂载数据: 无 ) 
│   │   │   │   └── Pod对象的容忍度 --> ( 难度等级: [0.5185, 0.5185) || 挂载数据: 无 ) 
│   │   │   └── Pod优选级和抢占式调度 --> ( 难度等级: [0.5185, 0.5188) || 挂载数据: 无 ) 
│   │   ├── Kubernetes系统扩展 --> ( 难度等级: [0.5188, 0.5202) || 挂载数据: 无 ) 
│   │   │   ├── 自定义资源类型（CRD） --> ( 难度等级: [0.5188, 0.5191) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建CRD对象 --> ( 难度等级: [0.5188, 0.5189) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 自定义资源格式验证 --> ( 难度等级: [0.5189, 0.5189) || 挂载数据: 无 ) 
│   │   │   │   ├── 子资源 --> ( 难度等级: [0.5189, 0.519) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用资源类别 --> ( 难度等级: [0.519, 0.519) || 挂载数据: 无 ) 
│   │   │   │   ├── 多版本支持 --> ( 难度等级: [0.519, 0.519) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义控制器基础 --> ( 难度等级: [0.519, 0.5191) || 挂载数据: blog: 4 ) 
│   │   │   ├── 自定义API Server --> ( 难度等级: [0.5191, 0.5194) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义API Server概述 --> ( 难度等级: [0.5191, 0.5192) || 挂载数据: blog: 1 ) 
│   │   │   │   └── APIService对象 --> ( 难度等级: [0.5192, 0.5194) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes集群高可用 --> ( 难度等级: [0.5194, 0.5196) || 挂载数据: 无 ) 
│   │   │   │   ├── etcd高可用 --> ( 难度等级: [0.5194, 0.5195) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Controller Manager和Scheduler高可用 --> ( 难度等级: [0.5195, 0.5196) || 挂载数据: blog: 4 ) 
│   │   │   ├── Kubernetes的部署模式 --> ( 难度等级: [0.5196, 0.5199) || 挂载数据: 无 ) 
│   │   │   │   ├── 关键组件 --> ( 难度等级: [0.5196, 0.5198) || 挂载数据: 无 ) 
│   │   │   │   └── 常见的部署模式 --> ( 难度等级: [0.5198, 0.5199) || 挂载数据: 无 ) 
│   │   │   └── 容器时代的DevOps概述 --> ( 难度等级: [0.5199, 0.5202) || 挂载数据: 无 ) 
│   │   │       ├── 容器：DevOps协作的基础 --> ( 难度等级: [0.5199, 0.52) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── 容器隔离等级 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 容器编排 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: blog: 5 ) 
│   │   │       │   ├── 将镜像存储在可信的注册服务器中 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 充分利用Docker的构建缓存 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 不要使用特权模式运行容器 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用显式的容器镜像标签 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 保持小的容器镜像 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 单个容器只运行一个应用 --> ( 难度等级: [0.5199, 0.52) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── 使用可信镜像仓库中经过验证的镜像 --> ( 难度等级: [0.52, 0.52) || 挂载数据: 无 ) 
│   │   │       │   ├── 对镜像进行漏洞扫描 --> ( 难度等级: [0.52, 0.52) || 挂载数据: 无 ) 
│   │   │       │   ├── 不要将数据保存在容器中 --> ( 难度等级: [0.52, 0.52) || 挂载数据: blog: 2 ) 
│   │   │       │   └── 永远不要在容器中存放密钥和配置 --> ( 难度等级: [0.52, 0.52) || 挂载数据: 无 ) 
│   │   │       ├── 泛型端到端容器应用程序生命周期工作流 --> ( 难度等级: [0.52, 0.5201) || 挂载数据: 无 ) 
│   │   │       └── 基于Kubernetes的DevOps --> ( 难度等级: [0.5201, 0.5202) || 挂载数据: blog: 10 ) 
│   │   ├── 资源指标及HPA控制器 --> ( 难度等级: [0.5202, 0.5215) || 挂载数据: 无 ) 
│   │   │   ├── 资源监控及资源指标 --> ( 难度等级: [0.5202, 0.5205) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源监控及Heapster --> ( 难度等级: [0.5202, 0.5203) || 挂载数据: 无 ) 
│   │   │   │   └── 新一代监控架构 --> ( 难度等级: [0.5203, 0.5205) || 挂载数据: 无 ) 
│   │   │   ├── 资源指标及其应用 --> ( 难度等级: [0.5205, 0.5208) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署metrics-server --> ( 难度等级: [0.5205, 0.5207) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl top命令 --> ( 难度等级: [0.5207, 0.5208) || 挂载数据: 无 ) 
│   │   │   ├── 自定义指标与Prometheus --> ( 难度等级: [0.5208, 0.5212) || 挂载数据: 无 ) 
│   │   │   │   ├── Prometheus概述 --> ( 难度等级: [0.5208, 0.5209) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Prometheus监控系统 --> ( 难度等级: [0.5209, 0.5211) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义指标适配器k8s-prometheus-adapter --> ( 难度等级: [0.5211, 0.5212) || 挂载数据: 无 ) 
│   │   │   └── 自动弹性缩放 --> ( 难度等级: [0.5212, 0.5215) || 挂载数据: 无 ) 
│   │   │       ├── HPA概述 --> ( 难度等级: [0.5212, 0.5213) || 挂载数据: 无 ) 
│   │   │       ├── HPA（v1）控制器 --> ( 难度等级: [0.5213, 0.5214) || 挂载数据: 无 ) 
│   │   │       └── HPA（v2）控制器 --> ( 难度等级: [0.5214, 0.5215) || 挂载数据: 无 ) 
│   │   ├── Helm程序包管理器 --> ( 难度等级: [0.5215, 0.5228) || 挂载数据: 无 ) 
│   │   │   ├── Helm基础 --> ( 难度等级: [0.5215, 0.522) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm的核心术语 --> ( 难度等级: [0.5215, 0.5216) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm架构 --> ( 难度等级: [0.5216, 0.5217) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Helm Client --> ( 难度等级: [0.5217, 0.5218) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Tiller server --> ( 难度等级: [0.5218, 0.5219) || 挂载数据: 无 ) 
│   │   │   │   └── Helm快速入门 --> ( 难度等级: [0.5219, 0.522) || 挂载数据: blog: 1 ) 
│   │   │   ├── Helm Charts --> ( 难度等级: [0.522, 0.5224) || 挂载数据: 无 ) 
│   │   │   │   ├── Charts文件组织结构 --> ( 难度等级: [0.522, 0.522) || 挂载数据: 无 ) 
│   │   │   │   ├── Chart.yaml文件组织格式 --> ( 难度等级: [0.522, 0.5221) || 挂载数据: 无 ) 
│   │   │   │   ├── Charts中的依赖关系 --> ( 难度等级: [0.5221, 0.5222) || 挂载数据: 无 ) 
│   │   │   │   ├── 模板和值 --> ( 难度等级: [0.5222, 0.5223) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义Charts --> ( 难度等级: [0.5223, 0.5224) || 挂载数据: 无 ) 
│   │   │   └── Helm实践：部署EFK日志管理系统 --> ( 难度等级: [0.5224, 0.5228) || 挂载数据: 无 ) 
│   │   │       ├── ElasticSearch集群 --> ( 难度等级: [0.5224, 0.5226) || 挂载数据: 无 ) 
│   │   │       ├── 日志采集代理fluentd --> ( 难度等级: [0.5226, 0.5227) || 挂载数据: 无 ) 
│   │   │       └── 可视化组件Kibana --> ( 难度等级: [0.5227, 0.5228) || 挂载数据: 无 ) 
│   │   ├── 夯实基础：Linux网络虚拟化 --> ( 难度等级: [0.5228, 0.5242) || 挂载数据: 无 ) 
│   │   │   ├── 网络虚拟化基石：network namespace --> ( 难度等级: [0.5228, 0.523) || 挂载数据: 无 ) 
│   │   │   │   ├── 初识network namespace --> ( 难度等级: [0.5228, 0.5229) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置network namespace --> ( 难度等级: [0.5229, 0.5229) || 挂载数据: 无 ) 
│   │   │   │   └── network namespace API的使用 --> ( 难度等级: [0.5229, 0.523) || 挂载数据: blog: 4 ) 
│   │   │   ├── 千呼万唤始出来：veth pair --> ( 难度等级: [0.523, 0.5231) || 挂载数据: 无 ) 
│   │   │   │   └── veth pair内核实现 --> ( 难度等级: [0.523, 0.5231) || 挂载数据: 无 ) 
│   │   │   ├── 连接你我他：Linux bridge --> ( 难度等级: [0.5231, 0.5233) || 挂载数据: 无 ) 
│   │   │   │   ├── Linux bridge初体验 --> ( 难度等级: [0.5231, 0.5232) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 把IP让给Linux bridge --> ( 难度等级: [0.5232, 0.5232) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 将物理网卡添加到Linux bridge --> ( 难度等级: [0.5232, 0.5232) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Linux bridge在网络虚拟化中的应用 --> ( 难度等级: [0.5232, 0.5233) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 网络接口的混杂模式 --> ( 难度等级: [0.5233, 0.5233) || 挂载数据: 无 ) 
│   │   │   ├── 给用户态一个机会：tun/tap设备 --> ( 难度等级: [0.5233, 0.5234) || 挂载数据: 无 ) 
│   │   │   │   ├── tun/tap设备的工作原理 --> ( 难度等级: [0.5233, 0.5233) || 挂载数据: 无 ) 
│   │   │   │   ├── 利用tun设备部署一个VPN --> ( 难度等级: [0.5233, 0.5234) || 挂载数据: 无 ) 
│   │   │   │   └── tun设备编程 --> ( 难度等级: [0.5234, 0.5234) || 挂载数据: 无 ) 
│   │   │   ├── iptables --> ( 难度等级: [0.5234, 0.5236) || 挂载数据: 无 ) 
│   │   │   │   ├── 祖师爷netfilter --> ( 难度等级: [0.5234, 0.5235) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables的三板斧：table、chain和rule --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── iptables的常规武器 --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: 无 ) 
│   │   │   │   ├── userspace模式 --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables模式 --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── IPVS模式 --> ( 难度等级: [0.5235, 0.5236) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables VS. IPVS --> ( 难度等级: [0.5236, 0.5236) || 挂载数据: 无 ) 
│   │   │   │   └── conntrack --> ( 难度等级: [0.5236, 0.5236) || 挂载数据: blog: 2 ) 
│   │   │   ├── 初识Linux隧道：ipip --> ( 难度等级: [0.5236, 0.5237) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试ipip隧道 --> ( 难度等级: [0.5236, 0.5237) || 挂载数据: 无 ) 
│   │   │   │   └── ipip隧道测试结果复盘 --> ( 难度等级: [0.5237, 0.5237) || 挂载数据: 无 ) 
│   │   │   ├── Linux隧道网络的代表：VXLAN --> ( 难度等级: [0.5237, 0.5239) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN协议原理简介 --> ( 难度等级: [0.5237, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN组网必要信息 --> ( 难度等级: [0.5238, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN基本配置命令 --> ( 难度等级: [0.5238, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN网络实践 --> ( 难度等级: [0.5238, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式控制中心 --> ( 难度等级: [0.5238, 0.5239) || 挂载数据: 无 ) 
│   │   │   │   └── 自维护VTEP组 --> ( 难度等级: [0.5239, 0.5239) || 挂载数据: 无 ) 
│   │   │   ├── 物理网卡的分身术：Macvlan --> ( 难度等级: [0.5239, 0.524) || 挂载数据: 无 ) 
│   │   │   │   ├── Macvlan五大工作模式解析 --> ( 难度等级: [0.5239, 0.5239) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试使用Macvlan设备 --> ( 难度等级: [0.5239, 0.524) || 挂载数据: 无 ) 
│   │   │   │   ├── Macvlan的跨机通信 --> ( 难度等级: [0.524, 0.524) || 挂载数据: 无 ) 
│   │   │   │   └── Macvlan与overlay对比 --> ( 难度等级: [0.524, 0.524) || 挂载数据: blog: 1 ) 
│   │   │   └── Macvlan的救护员：IPvlan --> ( 难度等级: [0.524, 0.5242) || 挂载数据: 无 ) 
│   │   │       ├── IPvlan简介 --> ( 难度等级: [0.524, 0.5241) || 挂载数据: 无 ) 
│   │   │       ├── 测试IPvlan --> ( 难度等级: [0.5241, 0.5241) || 挂载数据: 无 ) 
│   │   │       └── Docker IPvlan网络 --> ( 难度等级: [0.5241, 0.5242) || 挂载数据: 无 ) 
│   │   ├── 饮水思源：Docker网络模型简介 --> ( 难度等级: [0.5242, 0.5255) || 挂载数据: 无 ) 
│   │   │   ├── 主角登场：Linux容器 --> ( 难度等级: [0.5242, 0.5244) || 挂载数据: 无 ) 
│   │   │   ├── 打开万花筒：Docker的四大网络模式 --> ( 难度等级: [0.5244, 0.5246) || 挂载数据: 无 ) 
│   │   │   │   ├── bridge模式 --> ( 难度等级: [0.5244, 0.5245) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── host模式 --> ( 难度等级: [0.5245, 0.5245) || 挂载数据: 无 ) 
│   │   │   │   ├── container模式 --> ( 难度等级: [0.5245, 0.5246) || 挂载数据: 无 ) 
│   │   │   │   └── none模式 --> ( 难度等级: [0.5246, 0.5246) || 挂载数据: 无 ) 
│   │   │   ├── 最常用的Docker网络技巧 --> ( 难度等级: [0.5246, 0.5249) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器IP --> ( 难度等级: [0.5246, 0.5247) || 挂载数据: 无 ) 
│   │   │   │   ├── 端口映射 --> ( 难度等级: [0.5247, 0.5247) || 挂载数据: 无 ) 
│   │   │   │   ├── 访问外网 --> ( 难度等级: [0.5247, 0.5247) || 挂载数据: 无 ) 
│   │   │   │   ├── DNS和主机名 --> ( 难度等级: [0.5247, 0.5248) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义网络 --> ( 难度等级: [0.5248, 0.5248) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 发布服务 --> ( 难度等级: [0.5248, 0.5248) || 挂载数据: 无 ) 
│   │   │   │   └── docker link：两两互联 --> ( 难度等级: [0.5248, 0.5249) || 挂载数据: blog: 1 ) 
│   │   │   ├── 容器网络的第一个标准：CNM --> ( 难度等级: [0.5249, 0.5251) || 挂载数据: 无 ) 
│   │   │   │   ├── CNM标准 --> ( 难度等级: [0.5249, 0.5249) || 挂载数据: 无 ) 
│   │   │   │   ├── 体验CNM接口 --> ( 难度等级: [0.5249, 0.525) || 挂载数据: 无 ) 
│   │   │   │   ├── Libnetwork --> ( 难度等级: [0.525, 0.525) || 挂载数据: 无 ) 
│   │   │   │   └── Libnetwork扩展 --> ( 难度等级: [0.525, 0.5251) || 挂载数据: 无 ) 
│   │   │   ├── 天生不易：容器组网的挑战 --> ( 难度等级: [0.5251, 0.5253) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器网络挑战综述 --> ( 难度等级: [0.5251, 0.5252) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Docker的解决方案 --> ( 难度等级: [0.5252, 0.5252) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 第三方容器网络插件 --> ( 难度等级: [0.5252, 0.5253) || 挂载数据: 无 ) 
│   │   │   └── 如何做好技术选型：容器组网方案沙场点兵 --> ( 难度等级: [0.5253, 0.5255) || 挂载数据: 无 ) 
│   │   │       ├── 隧道方案 --> ( 难度等级: [0.5253, 0.5254) || 挂载数据: 无 ) 
│   │   │       ├── 路由方案 --> ( 难度等级: [0.5254, 0.5254) || 挂载数据: 无 ) 
│   │   │       ├── 容器网络组网类型 --> ( 难度等级: [0.5254, 0.5255) || 挂载数据: 无 ) 
│   │   │       └── 关于容器网络标准接口 --> ( 难度等级: [0.5255, 0.5255) || 挂载数据: 无 ) 
│   │   ├── 标准的胜利：Kubernetes网络原理与实践 --> ( 难度等级: [0.5255, 0.5269) || 挂载数据: 无 ) 
│   │   │   ├── 容器基础设施的代言人：Kubernetes --> ( 难度等级: [0.5255, 0.5256) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes简介 --> ( 难度等级: [0.5255, 0.5256) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes能做什么 --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: 无 ) 
│   │   │   │   ├── 如何用Kubernetes --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Docker在Kubernetes中的角色 --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: 无 ) 
│   │   │   ├── 终于等到你：Kubernetes网络 --> ( 难度等级: [0.5256, 0.5257) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络基础 --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── Kubernetes网络架构综述 --> ( 难度等级: [0.5256, 0.5257) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Kubernetes主机内组网模型 --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes跨节点组网模型 --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的hosts文件 --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Pod的hostname --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: 无 ) 
│   │   │   ├── Pod的核心：pause容器 --> ( 难度等级: [0.5257, 0.5258) || 挂载数据: 无 ) 
│   │   │   ├── 打通CNI与Kubernetes：Kubernetes网络驱动 --> ( 难度等级: [0.5258, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── 即将完成历史使命：Kubenet --> ( 难度等级: [0.5258, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   └── 网络生态第一步：CNI --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: blog: 2 ) 
│   │   │   ├── 找到你并不容易：从集群内访问服务 --> ( 难度等级: [0.5259, 0.526) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service详解 --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── Service的三个port --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── 你的服务适合哪种发布形式 --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service发现 --> ( 难度等级: [0.5259, 0.526) || 挂载数据: 无 ) 
│   │   │   │   ├── 特殊的无头Service --> ( 难度等级: [0.526, 0.526) || 挂载数据: 无 ) 
│   │   │   │   └── 怎么访问本地服务 --> ( 难度等级: [0.526, 0.526) || 挂载数据: 无 ) 
│   │   │   ├── 找到你并不容易：从集群外访问服务 --> ( 难度等级: [0.526, 0.5261) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes Ingress --> ( 难度等级: [0.526, 0.5261) || 挂载数据: 无 ) 
│   │   │   ├── 你的名字：通过域名访问服务 --> ( 难度等级: [0.5261, 0.5262) || 挂载数据: 无 ) 
│   │   │   │   ├── DNS服务基本框架 --> ( 难度等级: [0.5261, 0.5261) || 挂载数据: 无 ) 
│   │   │   │   ├── 域名解析基本原理 --> ( 难度等级: [0.5261, 0.5261) || 挂载数据: 无 ) 
│   │   │   │   └── 调试DNS --> ( 难度等级: [0.5261, 0.5262) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络策略：为你的应用保驾护航 --> ( 难度等级: [0.5262, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   └── 网络策略应用举例 --> ( 难度等级: [0.5262, 0.5263) || 挂载数据: 无 ) 
│   │   │   ├── 前方高能：Kubernetes网络故障定位指南 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── IP转发和桥接 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod CIDR冲突 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── hairpin --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看Pod IP地址 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   └── 故障排查工具 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   ├── 迈向云原生 --> ( 难度等级: [0.5263, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 找个合理的理由打破巨石应用 --> ( 难度等级: [0.5263, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 先解耦简单的服务 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 学会小规模的运维 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 使用防损层模式 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用刀砍模式 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 准备一个数据迁移策略 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 重写所有模板代码 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   └── 淘汰老代码 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   ├── 确保弹性 --> ( 难度等级: [0.5264, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 用重试来解决瞬时故障 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用有限次的重试 --> ( 难度等级: [0.5264, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 用断路器来处理非瞬时故障 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 优雅地降级 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用隔离模式 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现健康及就绪检查 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 为容器设定CPU和内存限制 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   └── 实现限速和限流 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   ├── 确保安全性 --> ( 难度等级: [0.5265, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全性需求同其他需求一样重要 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 在设计时就考虑安全性 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 授予最小访问权限 --> ( 难度等级: [0.5265, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全地存储所有密钥 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 模糊化数据 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 传输数据加密 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用联合身份管理 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes pod的隔离 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   ├── 处理数据 --> ( 难度等级: [0.5266, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用托管数据库和数据分析服务 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用符合数据需求的存储 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据保存在多个地域或可用区中 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用数据分区和复制以提高扩展性 --> ( 难度等级: [0.5266, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 避免过度获取及频繁的I/O操作 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 不要把业务逻辑放在数据库中执行 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用类生产环境数据来测试 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   └── 处理瞬时故障 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   ├── 性能和伸缩性 --> ( 难度等级: [0.5267, 0.5268) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计可扩展的无状态服务 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用平台的自动伸缩功能 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用缓存 --> ( 难度等级: [0.5267, 0.5268) || 挂载数据: 无 ) 
│   │   │   │   └── 用分区来实现超出服务限制的扩容 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: blog: 1 ) 
│   │   │   └── 运维 --> ( 难度等级: [0.5268, 0.5269) || 挂载数据: blog: 1 ) 
│   │   │       ├── 部署和发布是两项独立的活动 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 部署的内容要尽量小 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 组件层级的CI/CD定义 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 应用部署的一致性 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 采用零宕机发布 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 不要变更部署后的架构 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 使用容器化构建 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 用代码来描述基础设施 --> ( 难度等级: [0.5268, 0.5269) || 挂载数据: 无 ) 
│   │   │       ├── 使用命名空间来组织Kubernetes中的服务 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   │       ├── 环境间的隔离 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   │       ├── 分隔函数源代码 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   │       └── 关联代码提交和部署 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   ├── 刨根问底：Kubernetes网络实现机制 --> ( 难度等级: [0.5269, 0.5282) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes极客们的日常：DIY一个Ingress Controller --> ( 难度等级: [0.5269, 0.5273) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Ingress Controller的通用框架 --> ( 难度等级: [0.5269, 0.5271) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Nginx Ingress Controller详解 --> ( 难度等级: [0.5271, 0.5273) || 挂载数据: blog: 2 ) 
│   │   │   ├── 沧海桑田：Kubernetes DNS架构演进之路 --> ( 难度等级: [0.5273, 0.5278) || 挂载数据: 无 ) 
│   │   │   │   ├── Kube-dns的工作原理 --> ( 难度等级: [0.5273, 0.5275) || 挂载数据: 无 ) 
│   │   │   │   ├── 上位的CoreDNS --> ( 难度等级: [0.5275, 0.5276) || 挂载数据: 无 ) 
│   │   │   │   └── Kube-dns VS. CoreDNS --> ( 难度等级: [0.5276, 0.5278) || 挂载数据: blog: 8 ) 
│   │   │   └── 你的安全我负责：使用Calico提供Kubernetes网络策略 --> ( 难度等级: [0.5278, 0.5282) || 挂载数据: 无 ) 
│   │   │       ├── 部署一个带Calico的Kubernetes集群 --> ( 难度等级: [0.5278, 0.528) || 挂载数据: blog: 5 ) 
│   │   │       └── 测试Calico网络策略 --> ( 难度等级: [0.528, 0.5282) || 挂载数据: 无 ) 
│   │   ├── 百花齐放：Kubernetes网络插件生态 --> ( 难度等级: [0.5282, 0.5296) || 挂载数据: 无 ) 
│   │   │   ├── 从入门到放弃：Docker原生网络的不足 --> ( 难度等级: [0.5282, 0.5284) || 挂载数据: 无 ) 
│   │   │   ├── CNI标准的胜出：从此江湖没有CNM --> ( 难度等级: [0.5284, 0.5286) || 挂载数据: 无 ) 
│   │   │   │   └── CNI的工作原理 --> ( 难度等级: [0.5284, 0.5286) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络插件鼻祖flannel --> ( 难度等级: [0.5286, 0.5288) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel简介 --> ( 难度等级: [0.5286, 0.5287) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel安装配置 --> ( 难度等级: [0.5287, 0.5287) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── flannel backend详解 --> ( 难度等级: [0.5287, 0.5288) || 挂载数据: blog: 1 ) 
│   │   │   │   └── flannel与etcd --> ( 难度等级: [0.5288, 0.5288) || 挂载数据: blog: 7 ) 
│   │   │   ├── 全能大三层网络插件：Calico --> ( 难度等级: [0.5288, 0.529) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico简介 --> ( 难度等级: [0.5288, 0.5288) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Calico的隧道模式 --> ( 难度等级: [0.5288, 0.5289) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Calico --> ( 难度等级: [0.5289, 0.5289) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico报文路径 --> ( 难度等级: [0.5289, 0.529) || 挂载数据: 无 ) 
│   │   │   │   └── Calico使用指南 --> ( 难度等级: [0.529, 0.529) || 挂载数据: 无 ) 
│   │   │   ├── Weave：支持数据加密的网络插件 --> ( 难度等级: [0.529, 0.5292) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave简介 --> ( 难度等级: [0.529, 0.529) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave实现原理 --> ( 难度等级: [0.529, 0.5291) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave安装 --> ( 难度等级: [0.5291, 0.5291) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave网络通信模型 --> ( 难度等级: [0.5291, 0.5291) || 挂载数据: 无 ) 
│   │   │   │   └── Weave的应用示例 --> ( 难度等级: [0.5291, 0.5292) || 挂载数据: 无 ) 
│   │   │   ├── Cilium：为微服务网络连接安全而生 --> ( 难度等级: [0.5292, 0.5294) || 挂载数据: 无 ) 
│   │   │   │   ├── 以API为中心的微服务安全 --> ( 难度等级: [0.5292, 0.5293) || 挂载数据: 无 ) 
│   │   │   │   └── BPF优化的数据平面性能 --> ( 难度等级: [0.5293, 0.5294) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes多网络的先行者：CNI-Genie --> ( 难度等级: [0.5294, 0.5296) || 挂载数据: 无 ) 
│   │   │       ├── CNI-Genie功能速递 --> ( 难度等级: [0.5294, 0.5295) || 挂载数据: blog: 1 ) 
│   │   │       └── 容器多IP --> ( 难度等级: [0.5295, 0.5296) || 挂载数据: blog: 3 ) 
│   │   ├── Kubernetes网络下半场：Istio --> ( 难度等级: [0.5296, 0.5309) || 挂载数据: 无 ) 
│   │   │   ├── 微服务架构的大地震：sidecar模式 --> ( 难度等级: [0.5296, 0.5298) || 挂载数据: 无 ) 
│   │   │   │   ├── 你真的需要Service Mesh吗 --> ( 难度等级: [0.5296, 0.5296) || 挂载数据: 无 ) 
│   │   │   │   ├── sidecar模式 --> ( 难度等级: [0.5296, 0.5297) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Mesh与sidecar --> ( 难度等级: [0.5297, 0.5297) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service VS. Service Mesh --> ( 难度等级: [0.5297, 0.5298) || 挂载数据: 无 ) 
│   │   │   │   └── Service Mesh典型实现之Linkerd --> ( 难度等级: [0.5298, 0.5298) || 挂载数据: 无 ) 
│   │   │   ├── Istio：引领新一代微服务架构潮流 --> ( 难度等级: [0.5298, 0.5301) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio简介 --> ( 难度等级: [0.5298, 0.5299) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio安装 --> ( 难度等级: [0.5299, 0.53) || 挂载数据: 无 ) 
│   │   │   │   └── Istio路由规则的实现 --> ( 难度等级: [0.53, 0.5301) || 挂载数据: 无 ) 
│   │   │   ├── 一切尽在不言中：Istio sidecar透明注入 --> ( 难度等级: [0.5301, 0.5304) || 挂载数据: 无 ) 
│   │   │   │   ├── Init容器 --> ( 难度等级: [0.5301, 0.5302) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── sideca注入示例 --> ( 难度等级: [0.5302, 0.5302) || 挂载数据: 无 ) 
│   │   │   │   ├── 手工注入sidecar --> ( 难度等级: [0.5302, 0.5303) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动注入sidecar --> ( 难度等级: [0.5303, 0.5303) || 挂载数据: 无 ) 
│   │   │   │   └── 从应用容器到sidecar代理的通信 --> ( 难度等级: [0.5303, 0.5304) || 挂载数据: 无 ) 
│   │   │   ├── 不再为iptables脚本所困：Istio CNI插件 --> ( 难度等级: [0.5304, 0.5306) || 挂载数据: 无 ) 
│   │   │   └── 除了微服务，Istio还能做更多 --> ( 难度等级: [0.5306, 0.5309) || 挂载数据: 无 ) 
│   │   ├── 云原生简介 --> ( 难度等级: [0.5309, 0.5323) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统 --> ( 难度等级: [0.5309, 0.5314) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式系统的误区 --> ( 难度等级: [0.5309, 0.5311) || 挂载数据: blog: 1 ) 
│   │   │   │   └── CAP定理 --> ( 难度等级: [0.5311, 0.5314) || 挂载数据: 无 ) 
│   │   │   ├── 十二要素应用 --> ( 难度等级: [0.5314, 0.5318) || 挂载数据: 无 ) 
│   │   │   └── 可用性和服务等级协议 --> ( 难度等级: [0.5318, 0.5323) || 挂载数据: 无 ) 
│   │   ├── 云原生基础 --> ( 难度等级: [0.5323, 0.5336) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器架构 --> ( 难度等级: [0.5323, 0.5326) || 挂载数据: 无 ) 
│   │   │   ├── 函数计算 --> ( 难度等级: [0.5326, 0.5329) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写单一用途的函数 --> ( 难度等级: [0.5326, 0.5327) || 挂载数据: 无 ) 
│   │   │   │   ├── 避免串联函数 --> ( 难度等级: [0.5327, 0.5327) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数应保持轻量和简单 --> ( 难度等级: [0.5327, 0.5328) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现无状态函数 --> ( 难度等级: [0.5328, 0.5328) || 挂载数据: 无 ) 
│   │   │   │   ├── 分离函数入口和函数的业务逻辑 --> ( 难度等级: [0.5328, 0.5329) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 避免长时间运行的函数 --> ( 难度等级: [0.5329, 0.5329) || 挂载数据: 无 ) 
│   │   │   ├── 从虚拟机到云原生 --> ( 难度等级: [0.5329, 0.5333) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 提升和转变 --> ( 难度等级: [0.5329, 0.533) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 应用的现代化改造 --> ( 难度等级: [0.533, 0.5332) || 挂载数据: 无 ) 
│   │   │   │   └── 应用的优化 --> ( 难度等级: [0.5332, 0.5333) || 挂载数据: 无 ) 
│   │   │   └── 微服务 --> ( 难度等级: [0.5333, 0.5336) || 挂载数据: 无 ) 
│   │   │       ├── 微服务架构的优势 --> ( 难度等级: [0.5333, 0.5334) || 挂载数据: 无 ) 
│   │   │       └── 微服务架构带来的挑战 --> ( 难度等级: [0.5334, 0.5336) || 挂载数据: 无 ) 
│   │   ├── 云原生应用的设计 --> ( 难度等级: [0.5336, 0.5349) || 挂载数据: 无 ) 
│   │   │   ├── 云原生应用的基础 --> ( 难度等级: [0.5336, 0.5338) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 精益运营 --> ( 难度等级: [0.5336, 0.5337) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全性 --> ( 难度等级: [0.5337, 0.5337) || 挂载数据: 无 ) 
│   │   │   │   └── 可扩展性与成本 --> ( 难度等级: [0.5337, 0.5338) || 挂载数据: blog: 1 ) 
│   │   │   ├── 云原生与传统架构的对比 --> ( 难度等级: [0.5338, 0.5339) || 挂载数据: blog: 10 ) 
│   │   │   ├── API设计与版本控制 --> ( 难度等级: [0.5339, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── API的前后兼容 --> ( 难度等级: [0.5339, 0.534) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 语义版本号 --> ( 难度等级: [0.534, 0.5341) || 挂载数据: 无 ) 
│   │   │   ├── 服务间的通信 --> ( 难度等级: [0.5341, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   ├── 通信协议 --> ( 难度等级: [0.5341, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息协议 --> ( 难度等级: [0.5341, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列化的考虑因素 --> ( 难度等级: [0.5341, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── 幂等性 --> ( 难度等级: [0.5341, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 请求与响应 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布者与订阅者 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布者/订阅者模式与请求/响应模式间的选择 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 同步与异步 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计时考虑前后兼容性 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 封装好服务避免泄露内部细节 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 优先考虑异步通信 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用高效的序列化技术 --> ( 难度等级: [0.5342, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   ├── 用批处理来提高请求处理的效率 --> ( 难度等级: [0.5343, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   └── 拆分大的消息 --> ( 难度等级: [0.5343, 0.5343) || 挂载数据: 无 ) 
│   │   │   ├── 网关 --> ( 难度等级: [0.5343, 0.5344) || 挂载数据: 无 ) 
│   │   │   │   ├── 路由 --> ( 难度等级: [0.5343, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   ├── 聚合 --> ( 难度等级: [0.5343, 0.5344) || 挂载数据: 无 ) 
│   │   │   │   ├── 卸载 --> ( 难度等级: [0.5344, 0.5344) || 挂载数据: 无 ) 
│   │   │   │   └── 网关的实现 --> ( 难度等级: [0.5344, 0.5344) || 挂载数据: 无 ) 
│   │   │   ├── 出口网关 --> ( 难度等级: [0.5344, 0.5346) || 挂载数据: 无 ) 
│   │   │   ├── 服务网格 --> ( 难度等级: [0.5346, 0.5348) || 挂载数据: 无 ) 
│   │   │   └── 架构示例 --> ( 难度等级: [0.5348, 0.5349) || 挂载数据: 无 ) 
│   │   ├── 数据处理 --> ( 难度等级: [0.5349, 0.5363) || 挂载数据: 无 ) 
│   │   │   ├── 数据存储系统 --> ( 难度等级: [0.5349, 0.5352) || 挂载数据: 无 ) 
│   │   │   │   ├── 对象、文件和磁盘 --> ( 难度等级: [0.5349, 0.535) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库 --> ( 难度等级: [0.535, 0.535) || 挂载数据: 无 ) 
│   │   │   │   ├── 流和队列 --> ( 难度等级: [0.535, 0.5351) || 挂载数据: 无 ) 
│   │   │   │   ├── 区块链 --> ( 难度等级: [0.5351, 0.5351) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 数据存储的选择 --> ( 难度等级: [0.5351, 0.5352) || 挂载数据: 无 ) 
│   │   │   ├── 多数据存储下的数据 --> ( 难度等级: [0.5352, 0.5354) || 挂载数据: 无 ) 
│   │   │   │   ├── 捕获数据更改 --> ( 难度等级: [0.5352, 0.5352) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将更改作为事件写入更改日志 --> ( 难度等级: [0.5352, 0.5353) || 挂载数据: 无 ) 
│   │   │   │   ├── 事务监管 --> ( 难度等级: [0.5353, 0.5353) || 挂载数据: 无 ) 
│   │   │   │   ├── 事务回滚 --> ( 难度等级: [0.5353, 0.5353) || 挂载数据: 无 ) 
│   │   │   │   └── 提取、转换和加载 --> ( 难度等级: [0.5353, 0.5354) || 挂载数据: 无 ) 
│   │   │   ├── 客户端访问数据 --> ( 难度等级: [0.5354, 0.5356) || 挂载数据: 无 ) 
│   │   │   │   ├── 受限的客户令牌（代客密钥） --> ( 难度等级: [0.5354, 0.5355) || 挂载数据: 无 ) 
│   │   │   │   ├── 细粒度访问控制的数据库服务 --> ( 难度等级: [0.5355, 0.5355) || 挂载数据: 无 ) 
│   │   │   │   └── GraphQL数据服务 --> ( 难度等级: [0.5355, 0.5356) || 挂载数据: 无 ) 
│   │   │   ├── 可快速伸缩的数据 --> ( 难度等级: [0.5356, 0.5358) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据分片 --> ( 难度等级: [0.5356, 0.5357) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据缓存 --> ( 难度等级: [0.5357, 0.5358) || 挂载数据: 无 ) 
│   │   │   │   └── 内容分发网络 --> ( 难度等级: [0.5358, 0.5358) || 挂载数据: 无 ) 
│   │   │   ├── 数据分析 --> ( 难度等级: [0.5358, 0.5361) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 数据流 --> ( 难度等级: [0.5358, 0.5359) || 挂载数据: 无 ) 
│   │   │   │   ├── 批处理 --> ( 难度等级: [0.5359, 0.5359) || 挂载数据: 无 ) 
│   │   │   │   ├── 对象存储上的数据湖 --> ( 难度等级: [0.5359, 0.536) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据湖和数据仓库 --> ( 难度等级: [0.536, 0.536) || 挂载数据: 无 ) 
│   │   │   │   └── 分布式查询引擎 --> ( 难度等级: [0.536, 0.5361) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes中的数据库 --> ( 难度等级: [0.5361, 0.5363) || 挂载数据: 无 ) 
│   │   │       ├── StatefulSet --> ( 难度等级: [0.5361, 0.5362) || 挂载数据: 无 ) 
│   │   │       └── DaemonSet --> ( 难度等级: [0.5362, 0.5363) || 挂载数据: 无 ) 
│   │   ├── DevOps --> ( 难度等级: [0.5363, 0.5376) || 挂载数据: 无 ) 
│   │   │   ├── 什么是DevOps --> ( 难度等级: [0.5363, 0.5365) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 协作 --> ( 难度等级: [0.5363, 0.5363) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化 --> ( 难度等级: [0.5363, 0.5364) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 精益原则和流程 --> ( 难度等级: [0.5364, 0.5364) || 挂载数据: 无 ) 
│   │   │   │   ├── 度量 --> ( 难度等级: [0.5364, 0.5364) || 挂载数据: 无 ) 
│   │   │   │   └── 分享 --> ( 难度等级: [0.5364, 0.5365) || 挂载数据: 无 ) 
│   │   │   ├── 测试 --> ( 难度等级: [0.5365, 0.5367) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试替身 --> ( 难度等级: [0.5365, 0.5365) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化测试金字塔 --> ( 难度等级: [0.5365, 0.5366) || 挂载数据: 无 ) 
│   │   │   │   ├── 不同测试类型的适用时机 --> ( 难度等级: [0.5366, 0.5366) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试节奏 --> ( 难度等级: [0.5366, 0.5366) || 挂载数据: 无 ) 
│   │   │   │   └── 在生产环境中测试 --> ( 难度等级: [0.5366, 0.5367) || 挂载数据: 无 ) 
│   │   │   ├── 开发环境和工具 --> ( 难度等级: [0.5367, 0.5369) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发工具 --> ( 难度等级: [0.5367, 0.5367) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发环境 --> ( 难度等级: [0.5367, 0.5367) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 本地开发环境 --> ( 难度等级: [0.5367, 0.5368) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地开发环境结合远端集群 --> ( 难度等级: [0.5368, 0.5368) || 挂载数据: 无 ) 
│   │   │   │   ├── Skaffold开发工作流 --> ( 难度等级: [0.5368, 0.5368) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将远端集群路由到本地开发环境 --> ( 难度等级: [0.5368, 0.5368) || 挂载数据: 无 ) 
│   │   │   │   └── 云端开发环境 --> ( 难度等级: [0.5368, 0.5369) || 挂载数据: 无 ) 
│   │   │   ├── 持续集成/持续交付 --> ( 难度等级: [0.5369, 0.5371) || 挂载数据: 无 ) 
│   │   │   │   ├── 源代码管理 --> ( 难度等级: [0.5369, 0.5369) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建阶段 --> ( 难度等级: [0.5369, 0.5369) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试阶段 --> ( 难度等级: [0.5369, 0.537) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署阶段 --> ( 难度等级: [0.537, 0.537) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布阶段 --> ( 难度等级: [0.537, 0.537) || 挂载数据: 无 ) 
│   │   │   │   └── 发布后阶段 --> ( 难度等级: [0.537, 0.5371) || 挂载数据: 无 ) 
│   │   │   ├── 监控 --> ( 难度等级: [0.5371, 0.5373) || 挂载数据: 无 ) 
│   │   │   │   ├── 收集指标 --> ( 难度等级: [0.5371, 0.5372) || 挂载数据: 无 ) 
│   │   │   │   └── 服务的可观测性 --> ( 难度等级: [0.5372, 0.5373) || 挂载数据: 无 ) 
│   │   │   ├── 配置管理 --> ( 难度等级: [0.5373, 0.5374) || 挂载数据: 无 ) 
│   │   │   │   ├── 单一环境变量 --> ( 难度等级: [0.5373, 0.5373) || 挂载数据: 无 ) 
│   │   │   │   ├── 将配置数据放入存储卷中 --> ( 难度等级: [0.5373, 0.5373) || 挂载数据: 无 ) 
│   │   │   │   ├── 密钥保存 --> ( 难度等级: [0.5373, 0.5374) || 挂载数据: 无 ) 
│   │   │   │   └── 部署配置 --> ( 难度等级: [0.5374, 0.5374) || 挂载数据: 无 ) 
│   │   │   └── 持续集成/持续交付流程示例 --> ( 难度等级: [0.5374, 0.5376) || 挂载数据: 无 ) 
│   │   ├── 可移植性 --> ( 难度等级: [0.5376, 0.539) || 挂载数据: 无 ) 
│   │   │   ├── 可移植性的代价 --> ( 难度等级: [0.5376, 0.5383) || 挂载数据: 无 ) 
│   │   │   └── 何时及如何实现可移植性 --> ( 难度等级: [0.5383, 0.539) || 挂载数据: 无 ) 
│   │   │       ├── 标准化的接口 --> ( 难度等级: [0.5383, 0.5384) || 挂载数据: 无 ) 
│   │   │       ├── 共用的服务和功能 --> ( 难度等级: [0.5384, 0.5385) || 挂载数据: 无 ) 
│   │   │       ├── 抽象和分层 --> ( 难度等级: [0.5385, 0.5386) || 挂载数据: 无 ) 
│   │   │       ├── 第三方服务商的托管服务 --> ( 难度等级: [0.5386, 0.5388) || 挂载数据: 无 ) 
│   │   │       ├── 可移植性工具 --> ( 难度等级: [0.5388, 0.5389) || 挂载数据: 无 ) 
│   │   │       └── 把Kubernetes作为可移植性层 --> ( 难度等级: [0.5389, 0.539) || 挂载数据: 无 ) 
│   │   ├── 理论篇（技术进阶） --> ( 难度等级: [0.539, 0.5403) || 挂载数据: 无 ) 
│   │   │   ├── 鸟瞰云上Kubernetes --> ( 难度等级: [0.539, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   ├── 内容概要 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   ├── 云资源层 --> ( 难度等级: [0.539, 0.539) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 专有版 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 托管版 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   │   └── Serverless版 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   ├── 单机系统层 --> ( 难度等级: [0.539, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   ├── 集群系统层 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 专有版 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 托管版 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   │   └── Serverless版 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   └── 功能扩展层 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │       └── 日志 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   ├── 认识集群的大脑 --> ( 难度等级: [0.5391, 0.5392) || 挂载数据: 无 ) 
│   │   │   │   ├── 从控制器视角看集群 --> ( 难度等级: [0.5391, 0.5392) || 挂载数据: 无 ) 
│   │   │   │   └── 控制器示例 --> ( 难度等级: [0.5392, 0.5392) || 挂载数据: 无 ) 
│   │   │   │       ├── 服务控制器 --> ( 难度等级: [0.5392, 0.5392) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 路由控制器 --> ( 难度等级: [0.5392, 0.5392) || 挂载数据: 无 ) 
│   │   │   ├── 网络与通信原理 --> ( 难度等级: [0.5392, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   ├── 背景 --> ( 难度等级: [0.5392, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   ├── 阿里云Kubernetes集群网络大图 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 集群网络搭建 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 初始阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 节点阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   │   └── Pod阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   └── 通信原理 --> ( 难度等级: [0.5393, 0.5394) || 挂载数据: 无 ) 
│   │   │   ├── 节点伸缩的实现 --> ( 难度等级: [0.5394, 0.5395) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点增加原理 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 手动添加已有节点 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 自动添加已有节点 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群扩容 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   └── 自动伸缩 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点减少原理 --> ( 难度等级: [0.5394, 0.5395) || 挂载数据: 无 ) 
│   │   │   │   └── 节点池原理 --> ( 难度等级: [0.5395, 0.5395) || 挂载数据: 无 ) 
│   │   │   ├── 简洁的服务模型 --> ( 难度等级: [0.5395, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务的本质是什么 --> ( 难度等级: [0.5395, 0.5395) || 挂载数据: 无 ) 
│   │   │   │   ├── 自带通信员 --> ( 难度等级: [0.5395, 0.5396) || 挂载数据: 无 ) 
│   │   │   │   ├── 让服务照进现实 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Netfilter的实现 --> ( 难度等级: [0.5396, 0.5397) || 挂载数据: 无 ) 
│   │   │   │       ├── 过滤器框架 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │       ├── 节点网络大图 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │       ├── 升级过滤器框架 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │       └── 用自定义链实现服务的反向代理 --> ( 难度等级: [0.5396, 0.5397) || 挂载数据: 无 ) 
│   │   │   ├── 镜像下载自动化 --> ( 难度等级: [0.5397, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像下载这件小事 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   ├── 理解OAuth 2.0协议 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Docker扮演的角色 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 整体结构 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解docker login --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 拉取镜像是怎么回事 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Kubernetes实现的私有镜像自动拉取 --> ( 难度等级: [0.5397, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基本功能 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   │   └── 进阶方式 --> ( 难度等级: [0.5397, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   └── 阿里云实现的ACR credential helper --> ( 难度等级: [0.5398, 0.5398) || 挂载数据: blog: 10 ) 
│   │   │   ├── 日志服务的集成 --> ( 难度等级: [0.5398, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志服务介绍 --> ( 难度等级: [0.5398, 0.5398) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 采集方案介绍 --> ( 难度等级: [0.5398, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 方案简介 --> ( 难度等级: [0.5398, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 运行流程 --> ( 难度等级: [0.5398, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   └── 配置方式 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   └── 核心技术介绍 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │       ├── 背景 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │       ├── 实现方式 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │       └── alibaba-log-controller内部实现 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: blog: 1 ) 
│   │   │   ├── 集群与存储系统 --> ( 难度等级: [0.5399, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   ├── 从应用的状态谈起 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 无状态的应用 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   └── 有状态的应用 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   ├── 基本单元：Pod Volume --> ( 难度等级: [0.5399, 0.54) || 挂载数据: 无 ) 
│   │   │   │   ├── 核心设计：PVC与PV体系 --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   ├── 与特定存储系统解耦 --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Volume Plugin --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   │   ├── in-tree（内置） Volume Plugin --> ( 难度等级: [0.54, 0.54) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── out-of-tree（外置） Volume Plugin --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes CSI管控组件容器化部署 --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Kubernetes的存储 --> ( 难度等级: [0.54, 0.5401) || 挂载数据: 无 ) 
│   │   │   ├── 流量路由Ingress --> ( 难度等级: [0.5401, 0.5402) || 挂载数据: 无 ) 
│   │   │   │   ├── 基本原理 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基础用法 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 配置安全路由 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 全局配置和局部配置 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   └── 实现原理 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   ├── 场景化需求 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 多入口访问Ingress --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   └── 部署多套Ingress Controller --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取客户端真实IP地址 --> ( 难度等级: [0.5401, 0.5402) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解客户端真实IP地址的传递过程 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ExternalTrafficPolicy的影响 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   └── 如何获取客户端真实IP地址 --> ( 难度等级: [0.5401, 0.5402) || 挂载数据: 无 ) 
│   │   │   │   └── 白名单功能 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │   └── 升级设计与实现 --> ( 难度等级: [0.5402, 0.5403) || 挂载数据: 无 ) 
│   │   │       ├── 升级预检 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │       │   ├── 核心组件检查项 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │       │   └── 前置检查增项 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │       ├── 原地升级与替代升级 --> ( 难度等级: [0.5402, 0.5403) || 挂载数据: 无 ) 
│   │   │       │   ├── 原地升级 --> ( 难度等级: [0.5402, 0.5403) || 挂载数据: 无 ) 
│   │   │       │   └── 替代升级 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │       └── 升级三部曲 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │           ├── 升级Master节点 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │           ├── 升级Worker节点 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │           └── 核心组件升级 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   └── 实践篇（诊断之美） --> ( 难度等级: [0.5403, 0.5417) || 挂载数据: 无 ) 
│   │       ├── 节点就绪状态异常（一） --> ( 难度等级: [0.5403, 0.5405) || 挂载数据: 无 ) 
│   │       │   ├── Docker栈 --> ( 难度等级: [0.5403, 0.5404) || 挂载数据: 无 ) 
│   │       │   │   ├── docker daemon调用栈分析 --> ( 难度等级: [0.5403, 0.5404) || 挂载数据: 无 ) 
│   │       │   │   └── Containerd调用栈分析 --> ( 难度等级: [0.5404, 0.5404) || 挂载数据: 无 ) 
│   │       │   ├── 什么是D-Bus --> ( 难度等级: [0.5404, 0.5405) || 挂载数据: 无 ) 
│   │       │   │   ├── runC请求D-Bus --> ( 难度等级: [0.5404, 0.5404) || 挂载数据: blog: 1 ) 
│   │       │   │   └── 原因并不在D-Bus --> ( 难度等级: [0.5404, 0.5405) || 挂载数据: 无 ) 
│   │       │   └── Systemd是硬骨头 --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: blog: 2 ) 
│   │       │       ├── “没用”的core dump --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: blog: 1 ) 
│   │       │       ├── 零散的信息 --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: 无 ) 
│   │       │       ├── 代码分析 --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: 无 ) 
│   │       │       └── Live Debugging --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: 无 ) 
│   │       ├── 节点就绪状态异常（二） --> ( 难度等级: [0.5405, 0.5408) || 挂载数据: 无 ) 
│   │       │   ├── 节点状态机 --> ( 难度等级: [0.5405, 0.5406) || 挂载数据: 无 ) 
│   │       │   ├── 就绪三分钟 --> ( 难度等级: [0.5406, 0.5406) || 挂载数据: 无 ) 
│   │       │   ├── 止步不前的PLEG --> ( 难度等级: [0.5406, 0.5407) || 挂载数据: 无 ) 
│   │       │   ├── 无响应的Terwayd --> ( 难度等级: [0.5407, 0.5407) || 挂载数据: 无 ) 
│   │       │   ├── 原因 --> ( 难度等级: [0.5407, 0.5407) || 挂载数据: 无 ) 
│   │       │   └── 修复 --> ( 难度等级: [0.5407, 0.5408) || 挂载数据: 无 ) 
│   │       ├── 命名空间回收机制失效 --> ( 难度等级: [0.5408, 0.541) || 挂载数据: 无 ) 
│   │       │   ├── 集群管控入口 --> ( 难度等级: [0.5408, 0.5408) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间控制器的行为 --> ( 难度等级: [0.5408, 0.5409) || 挂载数据: 无 ) 
│   │       │   │   ├── 删除收纳盒里的资源 --> ( 难度等级: [0.5408, 0.5408) || 挂载数据: 无 ) 
│   │       │   │   ├── API、Group、Version --> ( 难度等级: [0.5408, 0.5408) || 挂载数据: 无 ) 
│   │       │   │   └── 控制器不能删除命名空间里的资源 --> ( 难度等级: [0.5408, 0.5409) || 挂载数据: 无 ) 
│   │       │   ├── 回到集群管控入口 --> ( 难度等级: [0.5409, 0.5409) || 挂载数据: 无 ) 
│   │       │   ├── 节点与Pod的通信 --> ( 难度等级: [0.5409, 0.5409) || 挂载数据: 无 ) 
│   │       │   └── 集群节点访问云资源 --> ( 难度等级: [0.5409, 0.541) || 挂载数据: 无 ) 
│   │       ├── 网络安全组加固对与错 --> ( 难度等级: [0.541, 0.5412) || 挂载数据: 无 ) 
│   │       │   ├── 安全组扮演的角色 --> ( 难度等级: [0.541, 0.5411) || 挂载数据: 无 ) 
│   │       │   ├── 安全组与集群网络 --> ( 难度等级: [0.5411, 0.5411) || 挂载数据: 无 ) 
│   │       │   └── 怎么管理安全组规则 --> ( 难度等级: [0.5411, 0.5412) || 挂载数据: 无 ) 
│   │       │       ├── 限制集群访问外网 --> ( 难度等级: [0.5411, 0.5412) || 挂载数据: 无 ) 
│   │       │       ├── IDC与集群互访 --> ( 难度等级: [0.5412, 0.5412) || 挂载数据: blog: 1 ) 
│   │       │       └── 使用新的安全组管理节点 --> ( 难度等级: [0.5412, 0.5412) || 挂载数据: 无 ) 
│   │       ├── 网格应用存活状态异常 --> ( 难度等级: [0.5412, 0.5414) || 挂载数据: 无 ) 
│   │       │   ├── 代理与代理的生命周期管理 --> ( 难度等级: [0.5412, 0.5413) || 挂载数据: 无 ) 
│   │       │   ├── 控制面和数据面 --> ( 难度等级: [0.5413, 0.5413) || 挂载数据: 无 ) 
│   │       │   ├── 简单的原因 --> ( 难度等级: [0.5413, 0.5414) || 挂载数据: 无 ) 
│   │       │   └── 阿里云服务网格（ASM）介绍 --> ( 难度等级: [0.5414, 0.5414) || 挂载数据: blog: 10 ) 
│   │       └── 网格自签名根证书过期 --> ( 难度等级: [0.5414, 0.5417) || 挂载数据: 无 ) 
│   │           ├── 连续重启的Citadel --> ( 难度等级: [0.5414, 0.5415) || 挂载数据: 无 ) 
│   │           ├── 一般意义上的证书验证 --> ( 难度等级: [0.5415, 0.5415) || 挂载数据: 无 ) 
│   │           ├── 自签名证书验证失败 --> ( 难度等级: [0.5415, 0.5416) || 挂载数据: 无 ) 
│   │           ├── 大神定理 --> ( 难度等级: [0.5416, 0.5416) || 挂载数据: 无 ) 
│   │           ├── Citadel证书体系 --> ( 难度等级: [0.5416, 0.5416) || 挂载数据: 无 ) 
│   │           └── 经验 --> ( 难度等级: [0.5416, 0.5417) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.5417, 0.5833) || 挂载数据: 无 ) 
│   │   ├── 运维 --> ( 难度等级: [0.5417, 0.5521) || 挂载数据: 无 ) 
│   │   │   └── 配置 --> ( 难度等级: [0.5417, 0.5521) || 挂载数据: 无 ) 
│   │   │       ├── CUE(Cisco Unity Express) --> ( 难度等级: [0.5417, 0.5434) || 挂载数据: blog: 8 ) 
│   │   │       ├── Jsonnet --> ( 难度等级: [0.5434, 0.5451) || 挂载数据: 无 ) 
│   │   │       ├── HCL --> ( 难度等级: [0.5451, 0.5469) || 挂载数据: 无 ) 
│   │   │       ├── BCL --> ( 难度等级: [0.5469, 0.5486) || 挂载数据: 无 ) 
│   │   │       ├── KubeVela --> ( 难度等级: [0.5486, 0.5503) || 挂载数据: 无 ) 
│   │   │       └── Terraform --> ( 难度等级: [0.5503, 0.5521) || 挂载数据: blog: 7 ) 
│   │   ├── API --> ( 难度等级: [0.5521, 0.5625) || 挂载数据: 无 ) 
│   │   │   ├── GraphQL --> ( 难度等级: [0.5521, 0.5556) || 挂载数据: 无 ) 
│   │   │   ├── Swagger UI --> ( 难度等级: [0.5556, 0.559) || 挂载数据: 无 ) 
│   │   │   └── gRPC --> ( 难度等级: [0.559, 0.5625) || 挂载数据: 无 ) 
│   │   ├── 诊断 --> ( 难度等级: [0.5625, 0.5729) || 挂载数据: 无 ) 
│   │   │   ├── OpenTracing标准 --> ( 难度等级: [0.5625, 0.5646) || 挂载数据: 无 ) 
│   │   │   ├── SkyWalking --> ( 难度等级: [0.5646, 0.5667) || 挂载数据: 无 ) 
│   │   │   ├── Zipkin --> ( 难度等级: [0.5667, 0.5687) || 挂载数据: 无 ) 
│   │   │   ├── Jaeger --> ( 难度等级: [0.5687, 0.5708) || 挂载数据: 无 ) 
│   │   │   └── Sonobuoy --> ( 难度等级: [0.5708, 0.5729) || 挂载数据: 无 ) 
│   │   └── 质量 --> ( 难度等级: [0.5729, 0.5833) || 挂载数据: 无 ) 
│   │       ├── Litmus --> ( 难度等级: [0.5729, 0.5781) || 挂载数据: 无 ) 
│   │       └── Sysbench --> ( 难度等级: [0.5781, 0.5833) || 挂载数据: 无 ) 
│   ├── 操作系统 --> ( 难度等级: [0.5833, 0.625) || 挂载数据: 无 ) 
│   │   ├── CoreOS --> ( 难度等级: [0.5833, 0.5972) || 挂载数据: blog: 1 ) 
│   │   ├── Alibaba Linux --> ( 难度等级: [0.5972, 0.6111) || 挂载数据: 无 ) 
│   │   └── Tencent Linux --> ( 难度等级: [0.6111, 0.625) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.625, 0.6667) || 挂载数据: 无 ) 
├── 云原生高阶-应用开发 --> ( 难度等级: [0.6667, 0.8333) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.6667, 0.7222) || 挂载数据: 无 ) 
│   │   └── BaaS Serverless --> ( 难度等级: [0.6667, 0.7222) || 挂载数据: 无 ) 
│   │       ├── Spring Cloud Connector --> ( 难度等级: [0.6667, 0.6944) || 挂载数据: 无 ) 
│   │       └── Open Service Broker --> ( 难度等级: [0.6944, 0.7222) || 挂载数据: 无 ) 
│   ├── 编程语言 --> ( 难度等级: [0.7222, 0.7778) || 挂载数据: 无 ) 
│   │   └── Java --> ( 难度等级: [0.7222, 0.7778) || 挂载数据: blog: 10 ) 
│   │       ├── 减小镜像 --> ( 难度等级: [0.7222, 0.7407) || 挂载数据: 无 ) 
│   │       │   ├── Alpine Portola --> ( 难度等级: [0.7222, 0.7284) || 挂载数据: 无 ) 
│   │       │   ├── JDK (version >= 9) --> ( 难度等级: [0.7284, 0.7346) || 挂载数据: 无 ) 
│   │       │   └── Spring Boot (version > 2.3) --> ( 难度等级: [0.7346, 0.7407) || 挂载数据: 无 ) 
│   │       ├── 降低资源占用率 --> ( 难度等级: [0.7407, 0.7593) || 挂载数据: 无 ) 
│   │       │   ├── Project Panama --> ( 难度等级: [0.7407, 0.75) || 挂载数据: 无 ) 
│   │       │   └── Project Valhalla --> ( 难度等级: [0.75, 0.7593) || 挂载数据: 无 ) 
│   │       └── 缩短冷启动时间 --> ( 难度等级: [0.7593, 0.7778) || 挂载数据: 无 ) 
│   │           ├── GraalVM --> ( 难度等级: [0.7593, 0.7639) || 挂载数据: blog: 2 ) 
│   │           ├── Quarkus --> ( 难度等级: [0.7639, 0.7685) || 挂载数据: blog: 1 ) 
│   │           ├── Micronaut --> ( 难度等级: [0.7685, 0.7731) || 挂载数据: 无 ) 
│   │           └── Helidon --> ( 难度等级: [0.7731, 0.7778) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.7778, 0.8333) || 挂载数据: 无 ) 
├── 云原生高阶-平台开发 --> ( 难度等级: [0.8333, 1.0) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.8333, 0.875) || 挂载数据: 无 ) 
│   │   ├── 接口 --> ( 难度等级: [0.8333, 0.8542) || 挂载数据: 无 ) 
│   │   │   ├── CNI(Container Network Interface) --> ( 难度等级: [0.8333, 0.8403) || 挂载数据: 无 ) 
│   │   │   │   ├── Flannel --> ( 难度等级: [0.8333, 0.8342) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico --> ( 难度等级: [0.8342, 0.8351) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave --> ( 难度等级: [0.8351, 0.8359) || 挂载数据: 无 ) 
│   │   │   │   ├── OVN(Open Virtual Network) --> ( 难度等级: [0.8359, 0.8368) || 挂载数据: 无 ) 
│   │   │   │   ├── SR-IOV(Single-root Input/Output Virtualization) --> ( 难度等级: [0.8368, 0.8377) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Romana --> ( 难度等级: [0.8377, 0.8385) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenContrail --> ( 难度等级: [0.8385, 0.8394) || 挂载数据: 无 ) 
│   │   │   │   └── Kuryr --> ( 难度等级: [0.8394, 0.8403) || 挂载数据: 无 ) 
│   │   │   ├── CRI(Container Runtime Interface) --> ( 难度等级: [0.8403, 0.8472) || 挂载数据: 无 ) 
│   │   │   │   └── Frakti --> ( 难度等级: [0.8403, 0.8472) || 挂载数据: 无 ) 
│   │   │   └── CSI(Container Storage Interface) --> ( 难度等级: [0.8472, 0.8542) || 挂载数据: 无 ) 
│   │   │       ├── FlexVolume --> ( 难度等级: [0.8472, 0.8507) || 挂载数据: 无 ) 
│   │   │       └── GlusterFS --> ( 难度等级: [0.8507, 0.8542) || 挂载数据: 无 ) 
│   │   └── PaaS --> ( 难度等级: [0.8542, 0.875) || 挂载数据: 无 ) 
│   │       ├── Cloud Foundry --> ( 难度等级: [0.8542, 0.8594) || 挂载数据: blog: 6 ) 
│   │       ├── Crossplane --> ( 难度等级: [0.8594, 0.8646) || 挂载数据: 无 ) 
│   │       ├── Anthos --> ( 难度等级: [0.8646, 0.8698) || 挂载数据: 无 ) 
│   │       └── KubeSphere --> ( 难度等级: [0.8698, 0.875) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │   └── 运维 --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │       └── 编程 --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │           ├── Operator --> ( 难度等级: [0.875, 0.8854) || 挂载数据: 无 ) 
│   │           ├── Pulumi --> ( 难度等级: [0.8854, 0.8958) || 挂载数据: 无 ) 
│   │           ├── Ballerina --> ( 难度等级: [0.8958, 0.9062) || 挂载数据: 无 ) 
│   │           └── cdk8s --> ( 难度等级: [0.9062, 0.9167) || 挂载数据: 无 ) 
│   ├── 中间件 --> ( 难度等级: [0.9167, 0.9583) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.9167, 0.9375) || 挂载数据: 无 ) 
│   │   │   └── Database Mesh --> ( 难度等级: [0.9167, 0.9375) || 挂载数据: 无 ) 
│   │   └── 大数据 --> ( 难度等级: [0.9375, 0.9583) || 挂载数据: 无 ) 
│   │       ├── Kubeflow --> ( 难度等级: [0.9375, 0.9444) || 挂载数据: 无 ) 
│   │       ├── Fluid --> ( 难度等级: [0.9444, 0.9514) || 挂载数据: 无 ) 
│   │       └── KubeTEE --> ( 难度等级: [0.9514, 0.9583) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.9583, 1.0) || 挂载数据: 无 ) 
└── 其他 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    ├── 应用类问题 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    └── 第三方包问题 --> ( 难度等级: [0, 0) || 挂载数据: 无 )