Найкращі практики Kubernetes

Я балакав з колишнім SRE Googler, який (правильно) вказав, що Kubernetes еволюціонує дуже швидко (занадто швидко для підтримки валюти), використовує (багато) нових концепцій і що існує (занадто) багато способів вирішити ту саму проблему.

Значна частина цього правдива і не обов'язково погана річ або не обов'язково відрізняється від будь-якої іншої технології. Я не погоджуюся з тим, що ці фактори стримували його прийняття Кубернетів. Я б закликав вас зануритися. Kubernetes - це його успіх, незважаючи на * ці (розумні) проблеми, тому що це дуже дуже добре.

У цій публікації я збираюся дати вам кілька найкращих практичних практик, які, сподіваюся, допоможуть вам захопити цю технологію за її контейнери та зануритися.

Ні в якому конкретному порядку:

  1. Нехай хтось ще зробить труд!

Використовуйте таку послугу Kubernetes, як Kubernetes Engine. Якщо ви не інтелектуально цікаві, розробник, що працює над Kubernetes або ви постачальник платформи, у якого клієнти просять послуги Kubernetes, збережіть клопоти і скористайтеся послугою Kubernetes. Ви будували власний дім та свій автомобіль? Або вам подобається спати в місці, коли Вовк не може збити і керувати автомобілем, який надійно веде вас з А до В?

Тож, якщо ви прочитали будь-яку з інших моїх публікацій, я також рекомендую оцінити регіональні кластери, щоб ви подивилися на щось таке:

Бета-контейнерні кластери gcloud створюють $ {CLUSTER} ...
gcloud-бета-контейнери кластери отримують облікові дані $ {CLUSTER} ...

І тоді ви готові піти з цим:

kubectl застосовувати --namename = marvels.yaml

2. Спробуйте подумати "Kubernetes"

Це * може бути складніше для Kubernetes Engine, ніж на інших платформах, але, на Cloud Cloud Platform, ви змушені підтримувати розуміння стану своїх ресурсів у Kubernetes (наприклад, Вузли, Інгреси) і, в той же час , основні ресурси в обчислювальній машині (наприклад, VM, HTTP / S балансири навантаження). Ця проблема подвійності хвильових хвиль є прикрою. Дякую Дейлу Х., що спершу сформулював це для мене.

Де це можливо, спробуйте дотримуватися мислення з точки зору ресурсів Kubernetes і ігноруйте основні ресурси GCE. Зараз, витративши більше року на обробку своєї роботи в Kubernetes, мені стало простіше думати чисто про "деяку кількість" Pods, що піддаються Службам (та Інгресам).

3. Простори імен, простори імен, простори імен

Оновлення: Дякую Майклу Хаузенбласу за те, що він навчав мене про найкращу практику * не * посилання на простори імен з файлів YAML Kubernetes. Хоча завжди слід використовувати простори імен, зазначення цих під час застосування файлу забезпечує більшу гнучкість і можливість використовувати ті самі файли YAML, наприклад, різні пейзажі. Дивіться статтю Майкла тут.

Ми з Майком Альтарасе розглядали місяці тому про простори імен в Кубернете і про те, де ви повинні їх використовувати. З тих пір я сильно ігнорував власну пораду, вважаючи, що мої випадки використання настільки незначні, що використання просторів імен буде непосильним. Я помилявся. Завжди використовуйте простори імен.

Оскільки контейнери для процесів, простори імен належать до проектів Kubernetes. Окрім межі безпеки, яку передає Namespaces, вони є прекрасним способом розділити вашу роботу, і вони дають чудовий спосіб її скинути або видалити:

kubectl видалити простір імен / $ WORKING_PROJECT

Єдиний мінус полягає в тому, що при використанні простору імен, які не за замовчуванням, вам потрібно буде вказати робочий простір імен - namespace = $ WORKING_PROJECT в командах kubectl, що, на мою думку, може стати хорошою захисною практикою. Однак ви завжди можете - всі простори імен або встановити інший простір імен за замовчуванням (посилання).

4. Занадто багато способів вирішити проблему

Це викликає занепокоєння. Я думаю, що це, мабуть, неправда, але, якщо немає гарних рекомендацій та найкращих практик, можливо, виявляється, що існує занадто багато подібних способів вирішити ту саму проблему. Я є загальним шаблоном, який я використовую, щоб викласти тут, щоб заохотити обговорення:

  • Файли YAML - це знання в холодному зберіганні (див. №5)
  • Ваші контейнери повинні робити одне добре (див. "Дистрибутив")
  • Завжди розгортайте розгортання (див. №6)
  • Якщо ви хочете L7 aka HTTP / S збалансування навантаження, використовуйте Ingress (див. №7 - га!)
  • Керуйте обліковими даними безпечно за допомогою Secrets (посилання)

5. Заперечення до kubectl застосовується - ім'я файлу над альтернативами

Легко отримати швидке звернення за допомогою kubectl createpace names / $ {WORKING_DIR}, але після кількох таких команд вам може бути цікаво, як ви дійшли до поточного стану і, що ще важливіше - як відтворити цей стан. Я рекомендую вам створити файли YAML для опису ваших ресурсів, а не еквівалентну команду створення kub ectl.

Я рекомендую вам ознайомитись з * відмінною * документацією Kubernetes API (посилання, посилання та 1.10), яка є вичерпною, точною та простою в навігації (можливо, ідеальною документацією !?). Але навіть з цим потужним інструментом іноді складно взяти команду kubectl, яка працює для вас, і перетворити її на YAML. Це не так:

kubectl отримати розгортання / $ {MY_DEPLOYMENT} --output = yaml
kubectl отримати послугу / $ {MY_SERVICE} --output = yaml
kubectl отримати що-небудь / $ {MY_ANYTHING} --output = yaml

Завантажте результати у файл, якщо хочете, але використовуйте їх як основу для еквівалентного (!) YAML-файлу. Вам потрібно буде скинути будь-які посилання на екземпляри.

Після того, як ви створили masterpiece.yaml, я рекомендую вам завжди звертатися до початкового створення, застосовувати будь-які наступні оновлення та, якщо потрібно видалити. Це воно!

kubectl застосувати --filename = masterpiece.yaml
kubectl delete --filename = masterpiece.yaml

Незначне розуміння: для розгортання вам не потрібно витягувати локальні файли YAML. Ви також можете надати kubectl apply --filename з URL-адресами і, поки будь-які залежні файли є локальними посиланнями, розгортання буде працювати.

Незначне розуміння: єдине місце, що я бачу, це використовується в Kubernetes-land, але це законна практика, ви можете комбінувати кілька файлів YAML в один файл YAML з роздільниками --- і ... файлів. Отже, замість простору імен YAML, розгортання YAML та сервісу YAML, у вас може бути мега-YAML, консолідуючи всі три файли в один.

Це дійсно YAML (скопіюйте та вставте його, наприклад, YAML Lint). Це * недійсна * специфікація Kubernetes | YAML, тому що кожна специфікація є неповною, але, якщо її було виконано, це ідеально YAML і є гарним способом зберегти пов'язані ресурси.

Дивіться #B (Xsonnet) про одну критику.

6. Використовуйте розгортання

У «Розгортаннях» є маса сил, достатньо моїх вказівок, щоб сказати: використовуйте «Розгортання» весь час, кожен раз. Навіть коли ви розгортаєте свій перший піднгінкс. Розгортання - це поїздки "першого класу" за ціною тренера, ви можете потрапляти в розгорнуті розгортання, помиляєтесь, повторно застосовуєтесь і Kubernetes дбає про вбивство неслухняних стручків і заміну їх на добре поводиться.

7. Балансовий навантажувач та Інгрес

Вони викликають плутанину. На мою думку (і я можу помилятися), коли я створюю Служби за допомогою --type = LoadBalancer, я хочу | отримати мережевий LB. Якщо я хочу HTTP / S (рівень 7) збалансування навантаження, мені потрібно створити Ingress. Ingress - заплутаний ресурс Kubernetes. Досить сказати, L7 == Похибка (і в результаті багато потужності конфігурації).

Kubernetes Engine проявляє ресурси Ingress як GCE HTTP / S-балансири навантаження. Крістофер Грант робить дуже гарну роботу, демістифікуючи Інгресу у своїх посадах (тут і тут).

8. NodePorts

Я не (ніколи?) Безпосередньо не створив кластерIP. Я вчинив з Kubernetes, що призвело до того, що послуги кластеру кластерів. Переважно (!) Я створив NodePorts або я роблю речі (наприклад, створюю ресурси Ingress), які використовують NodePorts.

NodePorts асоціюються з вузлами Kubernetes і вони є портами. Потужна умова, яку вони надають, полягає в тому, що * кожен * вузол кластеру (чи це NodePool? [[TODO]]) відкриває ту саму службу на одному і тому ж порту (вузла).

Якщо я створять службу, виставлену на NodePort X, я можу бути впевнений, що якщо я отримаю доступ до цього порту на * будь-якому * вузлі кластеру, я отримаю доступ до служби. Це лежить в основі можливостей збалансування навантаження Kubernetes, оскільки кластер здатний направляти вхідні запити на послугу до цього порту на будь-який вузол.

Google Cloud SDK (він же gcloud) включає в себе ssh-клієнт, який робить тривіальним підключення до комп'ютерів VM (які, як ви пам’ятаєте, Kubernetes Cluster Nodes). ssh-клієнт включає можливість переадресації портів. Отже, якщо ми хочемо підключитися до сервісу Kubernetes і зможемо шукати NodePort служби, то ми можемо тривіально (!) Переадресувати порт до цієї служби шляхом переадресації портів (використовуючи gcloud або будь-якого ssh-клієнта) до порту на будь-якому Вузол.

У наступному прикладі використовується kubectl для захоплення 0-го вузла в кластері. Назва вузла двигуна Kubernetes - те саме ім'я VM Compute Engine. З огляду на послугу під назвою $ {MY_SERVICE} у просторі імен, що називається $ {MY_NAMESPACE}, ми визначаємо NodePort служби. Потім ми переходимо на gcloud і використовуємо його вбудований ssh ​​для переходу до порту (використовуючи --ssh-flag = "- L XXXX: localhost: XXXX).

NODE_HOST = $ (\
  kubectl отримати вузли \
  --output = jsonpath = "{. items [0] .metadata.name}")
NODE_PORT = $ (\
  kubectl отримати послуги / $ {MY_SERVICE} \
  - namespace = $ {MY_NAMESPACE} \
  --output = jsonpath = "{. spec.ports [0] .nodePort}")
echo $ {NODE_PORT}
gcloud обчислити ssh $ {NODE_HOST} \
--ssh-flag = "- L $ {NODE_PORT}: localhost: $ {NODE_PORT}" \
--project = $ {YOUR_PROJECT}

Що в цьому так потужного? Тепер ви можете отримати доступ до служби так, як ніби він був локальним і без необхідності пробивати отвори в брандмауері.

NodePorts - це великі порти (~ 30 000–32,767).

9. Злом кубектла використання JSON

Google Cloud SDK (також gcloud) справді чудовий, але kubectl (Kubernetes CLI) є кращим (sic). Однією з потужних особливостей є форматування та фільтрування результатів. Це дозволяє некодувати (не-API-суперечки) способи розширення скриптів та інших інструментів інформацією з кластерів Kubernetes.

До всього стану ресурсів Kubernetes можна отримати доступ, наприклад, kubectl get (на мій досвід, більш корисні для цієї мети, ніж kubectl description) команди. Потім залишилося лише знайти голку в тому, що може бути стогом сіна JSON.

Хитрість полягає в тому, щоб:

kubectl get [ресурс] / [ресурс-ім'я] --output = JSON

А потім підкресліть результати, щоб почати створювати рядок запитів:

kubectl get [ресурс] / [ресурс-ім'я] --output = jsonpath = ". items [*]"

і ітературно уточнюйте встановлений результат, поки у вас не буде предметів, які ви шукаєте. Ось приклад, який повинен працювати з будь-яким кластером:

kubectl отримати вузли --output = json
kubectl отримати вузли --output = jsonpath = "{. items [*]}
kubectl отримати вузли --output = jsonpath = "{. items [0]}
kubectl отримати вузли --output = jsonpath = "{. items [0] .metadata.name}

Нарешті, є гідний аргумент (і принцип у * nix) для вивчення одного інструменту розбору JSON та застосування цього інструмента до всіх потреб JSON розбору. У цьому випадку чи є розумний конкурент jq? Підозрюю, що ні.

Плюс jq має чудовий майданчик (jqplay.org).

A. Використовуйте мітки

Це вже давно, але всі програмні послуги тепер підтримують концепцію довільного маркування ресурсів (як правило, пари ключ-значення). Причиною цього є те, що ці метадані забезпечують відкритий, повністю визначений користувачем спосіб запиту ресурсів. Кубернети використовує цей принцип притаманно; це невід'ємна здатність, а не подумка |

Служба Кубернетів виставляє довільну кількість кубернетівських стручків. Служби * не * виставляють Pods під назвою "Генрі" або Pods, що містять ReplicaSet. Натомість Сервіс виставляє Pods, етикетки яких відповідають критеріям, визначеним специфікацією Служби, і ці мітки, звичайно, визначені користувачем.

Примітка. У наведеному вище прикладі ми використовуємо простір імен під назвою project-x, і ця специфікація простору імен відображається в просторі імен (коли він створений), розгортанні, щоб визначити, де існує розгортання, і в Сервісі. Розгортання (яке називається мікросервіс-у) створить ReplicaSet (тут неявно вказано; це створено Розгортання), який підтримуватиме 100 Pods. Кожен Pod матиме додаток для мітки: publicname-a і міститиме один контейнер під назвою grpc-proxy на основі зображення під назвою image-grpc-proxy. Сервіс називається service-p. Принципово важливо, що Сервіс вибирає (!) Pods (лише в просторі імен проекту-x), які мають додаток для мітки: publicname-a. Сервіс вибере будь-який Pod (в просторі імен project-x), який має цю мітку (ключ: значення) пари * не * лише ті Pods, створені в цьому розгортанні. Сервіс не посилається на Pods за їх найменуванням (яке базується на назві розгортання), назвою контейнера, а також не на ім'я зображення контейнера, а лише на мітках, пов’язаних із стручком.

Примітка. Це * не * хороша практика, але це доводить суть. Якщо ви мали б запустити конфігурацію, подібну до наведеної, а потім окремо створити, напр. a Pod працює Nginx (у просторі імен project-x), а потім ви додали до нього додаток ярлика: publicname-a, воно швидко буде включено до набору Pods, що агрегуються службою service-p. Якби ви видалили мітку з будь-якого з Pods, агрегованого Сервісом, Струм перестане включатись.

Ця функція є прикладом прокрутки оновлень, коли Розгортання створює новий ReplicaSet, що містить нові Pods для версії X ', відмінні від ReplicaSet та Pods для версії X. Послуга може бути визначена для викриття перетину Pods, що працює в обох цих версіях, оскільки це не визначається термінами ReplicaSets або певними Pods, а визначеними користувачем мітками ("селекторами"), які застосовуються вами під час створення Pods.

Це дуже потужно!

B. Використовуйте Jsonnet, можливо, Ksonnet

Два виклики зі всіма (!?) Структурованими форматами (YAML, JSON, XML, CSV ;-) - це самопосилання та змінні. Під час складання специфікацій marvellous.yaml для розгортання Kubernetes ви з цим легко зіткнетеся. Ви знайдете літерали (наприклад, для імен зображень та дайджестів) і навіть із поважними розгортаннями, повторенням імен та селекторів.

Якщо ви обмежитеся YAML та JSON, ви не зможете вирішити ці проблеми. Компанія Google створила Jsonnet частково для вирішення цих проблем. Розумні люди з Гептіо поширили Джсонне на Кубернетес із… Ksonnet.

Обидва - це шаблонні мови, які вирішують проблеми, викладені вище (та більше). Я закликаю вас розглянути Jsonnet. Як і моя рекомендація розглянути можливість використання jq, вивчіть Jsonnet один раз і застосуйте його скрізь, де ви використовуєте JSON. Ksonnet характерний для Kubernetes, і - в моєму обмеженому (!) Досвіді - я виявив, що користь, отримана від цієї специфіки, не переважає кривою навчання.

C. YAML або JSON

Kubernetes трактує YAML та JSON переважно однаково. Особисто я вважаю YAML кращим для файлів конфігурації, які я kubectl - застосовую, оскільки YAML є більш лаконічним, ніж JSON. Хоча мені YAML важче писати.

Однак, якщо мова йде про розуміння структури та розбору, я вважаю за краще - вихід = JSON, а також тому, що - вихід = JSONPATH. Я великий шанувальник Golang, але шаблони Go не такі інтуїтивно зрозумілі, і я не використовую їх.

незначне розуміння: YAML - це суперсеть JSON (посилання)… зачекайте! що?

D. API та конфігурація собаки вниз

"API вниз", щоб дати йому своє правильне, хоч і не менш заплутане ім'я, - це умова в Кубернеті, завдяки якому Pods можуть отримати відчуття кластеру навколо них. Я припускаю, що нормальний потік відбувається із зовнішнього світу в піддон і його контейнери *, але * бувають випадки, коли контейнеру корисно (!) Отримувати інформацію про його оточення, наприклад, його ім'я вузла | IP, ім'я поділу (пробіл) | IP.

Значення низхідного API представлені контейнеру через змінні середовища. Змінні середовища використовуються (як і в іншому місці) для надання конфігурації або іншого стану контейнерам. Одним із приємних наслідків використання змінних оточуючих середовищ та впровадження API низхідних даних (з незначним застереженням) є те, що контейнер залишається від'єднаним від Kubernetes.

Ось приклад мого приятеля - Sal Rashid - який використовує API Downward для збору стану Node та Pod та подання їх користувачеві:

https://github.com/salrashid123/istio_helloworld/blob/master/all-istio.yaml

Примітка. Див. Розділи, що починаються з рядків 76, 80, 84, 88, де ім'я Pod, ім'я імен, IP та ім'я вузла під час виконання надаються низхідним API до контейнера з іменем myapp-container.

Низький API - єдиний, практичний спосіб зібрати ці дані для контейнера. Тож це скоріше "лише практика", а не "найкраща практика".

У багатьох своїх публікаціях, коли я будую рішення для Kubernetes, я перевіряю процес локально і поза контейнером, потім у контейнері (із зазначенням змінних умов середовища), потім у кластері Kubernetes. Механізми, що містять контейнери, є послідовними (див. Нижче), хоча один, як правило, працює на Докері, а один на Кубернетах.

У публікації, яку я нещодавно писав в ОС, оптимізованої контейнерами Google, я демонструю контейнер, який працює локально під Docker, віддалено під ОС, оптимізованої контейнерами, а потім на Kubernetes.

Ось працює під Docker локально. Зверніть увагу, як змінні середовища (--env) використовуються для надання конфігурації gcr.io/${PROJECT}/datastore.

docker run \
--інтерактивний \
--tty \
--publish = 127.0.0.1: 8080: 8080 \
--env = GCLOUD_DATASET_ID = $ {PROJECT} \
--env = GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--volume = $ PWD / $ {ROBOT} .key.json: / tmp / $ {ROBOT} .key.json \
gcr.io/${PROJECT}/datastore

Ось той самий результат, що перетворює розгортання на створення VM, оптимізованої контейнерами. Цього разу перевірте значення, вказані для прапора контейнера-env:

gcloud бета-обчислення екземплярів create-with-container $ {INSTANCE} \
--zone = $ {ZONE} \
--image-сім'я = cos-стабільна \
--image-project = cos-хмара \
--container-image=gcr.io/${PROJECT}/${IMAGE}@${DIGEST} \
--container-restart-policy = завжди \
--container-env = \
GCLOUD_DATASET_ID = $ {PROJECT}, \
GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--container-mount-host-path = \
mount-path = / tmp, \
хост-шлях = / tmp, \
режим = rw \
--project = $ {PROJECT}

І, нарешті, ось фрагмент YAML Розгортання для Кубернетів:

контейнери:
      - ім'я: сховище даних
        зображення: gcr.io/${PROJECT}/datastore
        imagePullPolicy: Завжди
        обсяг:
          - ім'я: сховище даних
            mountPath: / var / secrets / google
        env:
        - назва: GOOGLE_APPLICATION_CREDENTIALS
          значення: /var/secrets/google/datastore.key.json
        - назва: GCLOUD_DATASET_ID
          значення: $ {PROJECT}
        порти:
        - ім'я: http
          контейнерПорт: 8080

Тому я вважаю, що використання змінних оточуючих середовищ для config є досить незграбним. Немає чіткого навмисного прив’язки конкретних змінних оточуючих до певних процесів, і ви розумієте, що вони не налаштовані правильно, коли все порушується. Легко уявити змінні середовища, що конфліктують у не контейнерному середовищі, хоча це менше проблема з контейнерами, оскільки, як вище, ми чітко встановлюємо значення для конкретного контейнера.

Все сказане, використовуючи такі змінні середовища, є найкращою практикою.

E. Бічні вагони та чому Pods не завжди є синонімом контейнерів

5 кл коньяку
2 кл потрійна сек
2 кл лимонного соку
Приготування Вилийте всі інгредієнти в коктейльний коктейль, наповнений льодом. Добре струсіть і процідіть в склянку коктейлю.

Значну частину часу ви створите Kubernetes Pods, які містять окремі контейнери, і вам буде цікаво, чому там весь накладний струм, коли вам потрібен лише один контейнер. Струми є більш аналогічними хост-середовищу, який може запускати багато контейнерів. Тоді ви багато разів спробуєте запустити кілька контейнерів у Pod…

… І лише один раз, коли вам слід :-)

Напевно, більше, але дотримуйтесь лише одного разу.

Антидіаграма (не робіть цього) полягає в тому, щоб передбачити поточну конфігурацію (припустимо, веб-сервер і сервер бази даних) і закликте обидва в Pod. Це * не * гарна ідея *, якщо * кожен екземпляр веб-сервера повинен бути нерозривно і назавжди приєднаний до конкретного екземпляра бази даних. Це малоймовірно.

Що найімовірніше, це те, що екземпляри вашого веб-сервера мають масштабуватись за сукупним навантаженням на передній панелі, а екземпляри вашої бази даних повинні масштабуватись (незалежно від цього та) залежно від їх сукупної здатності боротися з навантаженням на передній панелі. Коли ви бачите сукупність, подумайте Сервіс і коли ви думаєте Сервіс, будь ласка, спробуйте передбачити довільну кількість Pods (тому що це має значення для вашого рахунку, але, для більшості інших цілей, неважливо, скільки Pods потрібні до тих пір, як номер є правильним для обслуговування робочого навантаження).

Коли слід розглянути кілька контейнерів на Pod? Єдиний час, коли це * завжди * має сенс, це коли ви хочете доповнити, розширити або збагатити поведінку основного Pod в контейнері. Перегляньмо приклад веб-сервера та бази даних зверху. У цьому сценарії, сподіваємось, ви тепер переконалися, що будете розгортати дві Служби (і дві розгортання), одну для фронтального періоду та одну для бекенда.

Хороша і поширена практика перед самим екземпляром вашого веб-сервера використовувати реверс-проксі. Зазвичай це буде або Nginx, або HAProxy, і все частіше стає користуватися посланцем (я рекомендую, якщо ви дивитесь на проксі, розглядати посланця; див. #F Istio). Реверс-проксі забезпечує послідовність (ми використовуємо лише напр. Envoy), навіть якщо ви використовуєте різні веб-сервери (наприклад, Apache, Tomcat w / Java тощо), навіть якщо у вас є трафік HTTP, gRPC, веб-сокетів тощо. , навіть якщо ви хочете направити деякий трафік на свій веб-сервер, а деякий трафік у кеш (наприклад, лак).

У всіх попередніх сценаріях було б доцільно використовувати модель «коляски». У цій моделі основний контейнер (ваш веб-сервер) має допоміжні, допоміжні контейнери (проксі-сервер посланця, кеш лаку тощо). Вони повинні бути щільно пов'язані з конкретним екземпляром веб-сервера * та * функціонально, комбінація - це "одиниця".

Дуже часто бачити реєстрацію, моніторинг, відстеження та інші інфраструктурні компоненти, що поставляються як бічні візки. Тут мотивація - відокремити проблеми. Надати розробникам послідовну вимогу, яка виробляє код, який "керується", і надає SRE можливість вибору бажаних інструментів, знаючи, що весь код у флоті буде реєструватися, випромінювати показники, бути відстежуваним, послідовно застосовувати auth тощо. Це шаблон що є основою службових мереж (див. #F Istio). Це остаточна найкраща, хоч і зароджуюча практика.

F. Використовуйте Istio

Використовуйте Istio обережно.

Istio (та інші сервісні сітки) - це відносно зароджені технології, що народилися від компаній (включаючи Google), які широко використовували контейнери. Сервісні сітки тривіально розміщують універсальний (у випадку Істіо, Посланець) проксі у кожному Pod, у кожному Розгортанні, у кожному просторі імен, у кожному кластері.

Результат - це послідовний субстрат управління, який дозволяє вільно з'єднати управління (сьогодні ми будемо використовувати Stackdriver Trace, але є план переходу на Jaeger, ми прокатуємо наш моніторинг Prometheus) та контрольні служби (ми знаємо, що всі наші послуги захищені, ми перенаправляємо 10% трафіку до канальних побудов служб A, B і C).

Я раджу «обережно», оскільки ці технології є новими, мають шорсткі краї і розвиваються швидко. Але переваги (гнучкість, спритність, стійкість до майбутнього) методологія дає вам, ймовірно, набагато перевершує витрати. Найголовніше, використовуйте службову сітку в якості своєї моделі з Kubernetes, навіть якщо ви ще не бажаєте застосовувати одну з технологій сервісної сітки.

Це все, шановні!