Рубрики
Uncategorized

Обучение использовать Кубернаны

В этом посте мы собираемся грязные руки и на самом деле использовать Куберовники. Мы сделаем образец AP … Теги с учебником, начинающими, Куберателями, дежопами.

В этом посте мы собираемся грязные руки и на самом деле использовать Куберовники. Мы возьмем приложение приложения, и я покажу вам, как запустить это на кластере Kubernetes. Для этого я рекомендую вам прочитать предыдущий пост, где я немного говорил о архитектуре Кубератеса.

Понимание Kubernetes может запутаться из-за простого количества вариантов, которые у вас есть. Чтобы избежать того, что я застрял в очень простое приложение и пытался сохранить язык статьи чрезвычайно просто, так что вы можете понять все основные концепции. После этого, чтобы получить более глубокое понимание рекомендуется, чтобы вы идете и проверить Официальные документы .

Основы

Давайте возьмем простое приложение Node.js (вам не нужно знать Node.js, чтобы следовать):

const express = require('express');

const app = express();

app.get('/', (req, res) => {
  res.send(`
    
Hello World!

  `);
});

app.listen(3000);

DockerFile для создания изображения для этого также довольно просто и будет выглядеть как что-то вроде этого:

FROM node

WORKDIR /app

COPY package.json .

RUN npm install

COPY . .

EXPOSE 3000

CMD [ "node", "app.js" ]

Теперь я покажу вам, как вы можете запустить это приложение на кластере Kubernetes и получить доступ к нему. Для этого нам понадобится следующие две вещи:

  1. Миникуба : Традиционно наш кластер у узлов работает на нескольких машинах, но для экспериментов, мы бы управляем все на нашей местной машине. Minikube в основном действует как наш кластер. И этот кластер будет иметь только один узел. Вы можете понять это лучше, думая как о главном, так и на уземе работника, работающего на одной машине (вашу локальную машину).

  2. kubectl : Это инструмент командной строки, который мы используем для отправки инструкций на наш кластер. С помощью этого инструмента мы можем отправлять инструкции на узел Master, который будет делать все необходимое, чтобы выполнить наши инструкции, с рабочими узлами.

Итак, у нас есть наш кластер, на котором мы хотим запустить наше приложение Node.js. Нам не нужно много беспокоиться о том, как кластер работает внутри, потому что K8S позаботится об этом для нас. И нам также не нужно беспокоиться о настройке этого кластера правильно, так как мы используем Minikube, и это сделает все для нас.

  1. Minikube Start начну наш кластер.
  2. Миникуба Стоп остановит это.

Мы собираемся сосредоточиться на понимании команд, которые мы отправим к кластеру (используя kubectl). Сейчас здесь есть два способа. Это вроде как случай с Docker и Docker-Compose. Существует императивный подход, в котором мы вручную вводят команды каждый раз (например, с Docker ) и есть декларативный подход, в котором мы перечисляем все, что мы хотим в Ямл Файл и все заботится автоматически (как мы сделали с Docker-Compose ).

Как только вы понимаете императивный подход, вы поймете декларативный интуитивно. Так вот почему давайте сначала посмотрим на императив.

Но прежде чем мы начнем с того, что есть несколько концепций, которые я чувствую, я должен объяснить ранее, так что понимание обоих подходов легче.

Введение в объекты

Кубернаны не работают с контейнерами напрямую. Вместо этого он работает с вещами, называемыми «объектами». Если вы простым поиском Google для того, что объекты Kubernetes вы, скорее всего, получите это определение:

» Объекты Kubernetes являются стойкими сущностями в кластере ».

Не имеет большого смысла, не так ли?: P Не волнуйтесь, это не имеет смысла мне тоже сначала. Я собираюсь попросить вас нести меня в течение некоторого времени и отпустить эту зуд понять, что именно объект. К тому времени, что все станет намного более понятно, и посмотрите объекты в действии, но на данный момент, давайте просто помним, что K8S работает с объектами.

Три объекта, на которых мы будем смотреть в этой статье:

  1. Объект POD.
  2. Объект развертывания.
  3. Объект сервиса.

Мы создаем объекты с использованием команд. Эти команды либо даны императивным образом или декларативным образом. Как только мы создадим объект K8S, примет этот объект создания, а затем будет делать вещи на основе инструкций, закодированных в этом объекте. И это все, что вам нужно, чтобы понять сейчас.

Мы создаем объект -> K8S Делает «что-то» на основе инструкций в этом объекте.

Еще одна вещь, которую я хочу убрать заранее, это то, что вы можете подумать, что мы будем создавать объекты POD. Это логическое предположение, поскольку в последнем посте я сказал вам, что PODS в основном обернуты для наших контейнеров, и поскольку приложение работает внутри контейнера, оно имеет смысл, что мы создаем объекты POD, чтобы запустить приложение, нет?

Обычно мы не создаем объекты POD самостоятельно и вручную перемещают их на какой-то узел рабочего. Вместо этого мы создаем объект развертывания, к которому мы тогда дам инструкции по количеству стручков и контейнеров, оно должно создавать и управлять для нас.

TLDR

Все это может казаться немного запутанным прямо сейчас, но просто имейте в виду, что эти основные вещи и вещи станут намного более понятно, как только вы увидите его в действии:

  1. Миникуба позаботится о создании нашего кластера.
  2. Мы будем использовать kubectl поговорить с нашим кластером.
  3. K8S работает с объектами.
  4. Существует два способа создания объектов: императив (например, использование Docker из командной строки) и декларативным (например, использование Docker-Compose)
  5. Мы создадим объекты развертывания, и эти объекты развертывания будут позаботиться о объектах POD, которые необходимо создать, чтобы запустить наше приложение.

Со всей это с пути, давайте наконец начнете:)

Императивный путь

Первые вещи сначала давайте закончимся кластером, используя

Minikube Start.

Сейчас мы имеем дело с контейнерами в конце дня, нам нужно создать изображение с нашего DockerFile. Это можно сделать просто используя эту команду:

docker build -t node-image .

Убедитесь, что вы находитесь в каталоге, содержащем DockerFile. Узел-изображение это просто тег, который я решил дать этому образу.

Теперь вы должны понимать, что наш кластер не зависит от локальной машины. Мы выпускаем инструкции кластеру с локальной машины, используя kubectl Отказ Таким образом, мы не сможем отправить наше изображение через локальную машину. Вот почему мы загружаем изображение, которое мы только что создали для Docker Hub. . Как только мы сделали это, мы приятно идти.

Теперь, что мы собираемся сделать, это создать объект развертывания. Для этого используйте следующую команду:

kubectl create deployment node-app --image=YourDockerHubName/node-image

Здесь Узел-приложение это имя, которое я решил дать этому развертыванию. Указанный образ — это тот, который следует использовать для контейнера POD, созданного этим развертыванием. Созданный объект автоматически отправляется в кластер Kubernetes, а затем кластер ищет изображение на Docker Hub Отказ

Подождите несколько секунд, а затем запустите

kubectl get deployments

Вы увидите, что мы были успешными. Мы также можем увидеть, что POD, созданный этим развертыванием, не работает, используя эту команду:

kubectl get pods

Также, если вы хотите удалить это развертывание команды для этого:

kubectl delete deployment node-app

Теперь, когда у нас есть подп.

Стручки имеют внутренний IP-адрес по умолчанию, но мы не можем использовать его для доступа к POD снаружи кластера. Кроме того, этот IP-адрес меняется всякий раз, когда заменяется POD, который бывает чаще, чем вы себе представляете, поскольку K8s управляет стручками для нас на основе различных факторов.

Так что для достижения стручка (и, следовательно, контейнер, работающий в POD), нам нужен сервисный объект. Этот сервисный объект отвечает за разоблачение стручков на другие стручки в кластере и пользователям за пределами кластера. Последнее соответствует нашему случаю текущего использования.

Хотя немного технического я хотел бы кратко рассказать о том, как работает сервисный объект на самом деле работает. Сервисные группы Стручки вместе и дают им общий IP-адрес, который не изменится. Затем мы также можем сказать услугу, чтобы выставить этот адрес за пределами кластера.

Так что давайте создадим услугу!

Вы бы подумали, что мы сделаем что-то вроде Kubectl Создать сервис .. но нет. На самом деле есть гораздо более простая команда, чтобы разоблачить POD, созданное развертыванием, что является Kubectl выставляют .. Отказ Эта команда открывает PODS, созданные развертыванием Создание такого обслуживания Отказ Просто запустите следующее, чтобы сделать это:

kubectl expose deploytment node-app --type=LoadBalancer --port=3000

Здесь нужно объяснить две вещи:

  1. --тып = LoadBalancer : --тып используется для указания типа сервиса, который мы хотим создавать. LoadBalancer Тип использует Балансировщик нагрузки И тогда этот балансировщик нагрузки не только генерирует уникальный адрес для этой услуги (который мы можем использовать, чтобы наконец-то взаимодействовать с нашим приложением), но также равномерно распределяет входящий трафик во всех стручках, которые являются частью этой услуги (хотя это не Здесь много релевантности, так как мы экспериментируем на местном уровне).

  2. --port = 3000 : Здесь мы просто упоминаем порт, который мы выбрали в коде нашего приложения Node.js.

С этим наш сервис сейчас создан. Вы можете запустить

kubectl get services

Чтобы увидеть услугу, которую мы только что создали перечисленные там.

Было бы дополнительное обслуживание, которое мы не создавали уже присутствующие. Не нужно быть встревоженным этим:)

Но опять же вы можете спросить: как мы видим наше приложение в действии?!

Ну, если бы мы создали эту услугу на облачном провайдере, мы бы увидели внешний IP (после запуска Kubectl Get Services ), что мы могли бы использовать. Но так как мы не делали этого, мы используем специальную команду minikube:

minikube service node-app

Запустите это, и он должен автоматически взять вас в окно браузера, где вы увидите «Hello World!» С сервера Node.js написано.

И woohoo! Это было. Вы успешно попали в руки с K8s сейчас! 😉

Это было это для императивного подхода. Давайте теперь посмотрим на декларативный подход. Прежде чем делать это обязательно удалить службу и развертывание, которое мы только что создали:

kubectl delete service node-app
kubectl delete deployment node-app

Декларативный путь

Теперь, когда у нас есть тяжелая часть понимания того, что происходит покрыто, жизнь намного проще отсюда. В декларативный способ мы просто будем создавать два файла:

  1. Развертывание.ямл — Для нашего объекта развертывания
  2. Service.yaml — Для нашего сервисного объекта.

После этого мы будем «применять» эти файлы, используя:

kubectl apply -f=deployment.yaml -f=service.yaml

Обязательно запустите эту команду в каталоге, где присутствуют эти файлы.

После этого просто работает:

minikube service node-app-service

Приведет нас к браузеру, где мы увидим приложение в действии.

Теперь, когда вы знаете поток, что просто остается посмотреть на два Ямл файлы. Большая часть того, что написано в этих файлах, должно чувствовать интуитивность после нашего обсуждения императивного метода выше. Я покажу вам файлы и объясните определенные моменты, но большинство из них просто связано с синтаксисом, который вы всегда можете посмотреть в официальной документации. Итак, давайте теперь посмотрим на файлы один за другим:

Развертывание.ямл :

apiVersion: apps/v1 
kind: Deployment 
metadata:
  name: node-app-deployment
spec:
  replicas: 1 
  selector: 
    matchLabels: 
      anything: node-app 
  template: 
    metadata:
      labels:
        anything: node-app
    spec: 
      containers:
        - name: node-app-container 
          image: YourDockerHubName/node-image
  1. Сначала мы указываем, какую версию API Kubernetes мы используем для создания этого объекта: Приложения/V1 Отказ Вы всегда можете видеть, какой из них выбрать из документов.
  2. Затем мы говорим, какой объект этот файл для.
  3. Мы также предоставляем имя под метаданными.
  4. Спец будет иметь основной кусок того, что мы хотим описать. Здесь мы опишем спецификацию развертывания.
  5. Реплики упоминают, сколько стручков по умолчанию мы хотим создать наше развертывание. Если не упомянуто, то значение по умолчанию равно 1.
  6. Под селекторами мы используем Matchlabels А затем укажите этикетки, которые мы будем упоминать ниже, когда мы определяем метаданные для наших стручков. Здесь ключ и значение являются как произвольными значениями. В приведенном выше примере я выбрал ключ быть что-нибудь и ценность быть Узел-приложение Отказ Вы могли бы выбрать что-то еще.
  7. После этого мы упоминаем шаблон. Здесь мы определяем стручки, которые должны быть созданы. Это похоже на когда мы использовали - ИМУТЬ в императивном подходе. Обратите внимание, что шаблон развертывания всегда будет описывать POD, поэтому нам не нужно явно упоминать явно говоря уже о том, что мы будем описывать POD.
  8. POD мы указываем, будут иметь метаданные, где мы упоминаем этикетки. Именно эти этикетки, которые мы указали выше в селекторе, так что развертывание знает, какие стручки это управлять позже.
  9. Мы также упоминаем спецификацию стручка под Спец И предоставить подробную информацию о контейнерах, где мы упоминаем изображение, на котором контейнер должен быть основан на.

Это было это для OUT Развертывание.ямл файл. Теперь давайте посмотрим на наш Service.yaml файл:

apiVersion: v1 
kind: Service
metadata:
  name: node-app-service
spec:
  selector: 
    anything: node-app 
  ports:
    - protocol: "TCP"
      port: 80 
      targetPort: 3000
  type: LoadBalancer
  1. Снова мы указываем версию API (хотя здесь немного по-другому). Вы можете посмотреть на что-то вроде Это Чтобы увидеть, какую версию API выбрать или проверять примеры в официальных документах.
  2. Затем мы указываем селектор, как и раньше. Здесь нам не нужно использовать Matchlabels Так как он использует Matchlabels по умолчанию.
  3. После этого мы просто упоминаем порты и тип. Цельюпорт Является ли тот, который мы указали для нашего приложения в коде, и порт является внешним портом, к которому мы хотим разоблачить. Мы могли бы выбрать другой протокол тоже Но вот я пошел с TCP.

И VOILA! Выполните команды, которые я упомянул выше, и вы должны быть хороши, чтобы пойти с декларативным способом создания объектов!

Заключение

Это, вероятно, был самый длинный пост, который я когда-либо писал просто потому, что было так много, чтобы покрыть. Если вы чувствуете себя пораженным, попробуйте прочитать его в частях и понимании. Я пытался стремиться к простоте более чем технической точности, чтобы вы сможете сделать лучшее чувство того, что происходит. Я снова рекомендую вам прочитать Официальные документы Так что у вас более глубокое знание о работе K8S.

С этим я надеюсь, что вы смогли узнать что-то из этого. Спасибо тонну для чтения:)

Если у вас есть какие-либо отзывы для меня или просто хочу поговорить, не стесняйтесь связываться со мной на Twitter Отказ Я буду более чем рад услышать от вас!: D.

Оригинал: «https://dev.to/rinkiyakedad/learning-to-use-kubernetes-1l6g»

Читайте ещё по теме: