Рубрики
Uncategorized

Окончательное руководство по Кубернетикам

В этом руководстве вы узнаете все, что вам нужно знать о Kubernetes и как вы можете использовать его, чтобы … Tagged с Куберовщиком, докером, дежоптом.

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

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

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

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

Итак, не тратя впустую дальнейшее время, давайте начнем.

Зачем заботиться о Кубернетах?

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

Портативность:

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

Масштабируемость:

Определение сложных контейнерных приложений и развертывание их во всем мире по нескольким кластерам серверов производится простым, так как Kubernetes оптимизирует ресурсы в соответствии с вашим желаемым состоянием. Когда Kubernetes весывает приложения горизонтально, он также автоматически отслеживает и поддерживает здоровье контейнера.

Расширение:

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

Концепции Кубератеса

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

Стручки:

POD — это группа нескольких контейнеров вашего приложения, которая обменивается хранением, уникальный кластер IP-адреса и информация о том, как их запустить (например, изображение контейнера, порты, перезагрузки и политики отказа).

Это строительный блок платформы Кубернетиков. Когда мы создаем развертывание или услугу, Kubernetes автоматически создает POD с контейнером внутри.

Каждый POD работает на узле, он запланирован и остается там до завершения или удаления. Если узел не удается или завершится, Kubernetes автоматически планирует идентичные стручки на других доступных узлах кластера.

Узел:

Узел является рабочей машиной в кластере Kubernetes и может быть либо виртуальной или физической машиной, в зависимости от типа кластера. Каждый узел управляется так называемым мастером. Мастер автоматически расплачивается PODS по всем узлам в кластере, в зависимости от их доступных ресурсов и текущей конфигурации.

Каждый узел должен запускать как минимум два сервиса:

  • Kublet — процесс, ответственный за связь между мастером Kubernetes и узлом
  • Время выполнения контейнера — отвечает за вытягивание и управление изображением контейнера (например, Docker)

Услуги:

Сервис — это абстракция, которая определяет логический набор стручков и политика, к которой к ним доступ. Услуги включают свободную муфту между зависимыми стручками.

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

Услуги могут быть выставлены несколькими способами:

  • Clusterip (Standard) — разоблачить только порт до внутренних органов кластера
  • NODEPORT — разоблачить службу в одном и том же порту на каждом узле в кластере, используя NAT
  • LoadBalancer — создайте внешний балансировщик нагрузки для экспорта сервиса по определенному IP-адресу

Развертывание:

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

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

Установка

Прежде чем мы сможем начать создавать наш кластер, нам сначала нужно установить Kubernetes на нашу локальную машину.

Docker Desktop:

Если вы используете Docker Desktop на Windows или Mac, вы можете установить Kubernetes непосредственно в окне настроек пользовательского интерфейса.

Другая установка:

Если вы не используете Docker Desktop, я бы порекомендовал подписаться на Официальное руководство по установке Для установки Kubectl и Minikube.

Kubernetes Основы

Теперь, когда у нас есть самые важные концепции, которые давайте продолжим, посмотрев на практическую сторону Куберанес. Эта глава проведет вас через все основы, которые вам нужно знать, чтобы развернуть приложения в кластере.

Создание кластера:

Minikube автоматически создает кластер, когда вы начнете его.

minikube start

Docker Desktop также должен автоматически создавать кластер после установки. Вы можете проверить, работает ли ваш кластер с помощью следующих команд:

# Get information about the cluster
kubectl cluster-info

# Get all nodes of the cluster
kubectl get nodes

Развертывание приложения:

Теперь, когда мы закончили установку и настроили наш первый кластер, пришло время развернуть приложение в Kubernetes.

kubectl create deployment nginx --image=nginx:latest

Мы используем команду «Создать развертывание» и передайте имя развертывания и изображения контейнера в качестве аргументов. В этом примере создается развертывание Nginx с одним контейнером и одной репликой.

Вы можете увидеть ваши развертывания для работы с помощью команды Get Deployments.

kubectl get deployments

Получить информацию о вашем развертывании:

Вот несколько команд, которые вы можете использовать для получения дополнительной информации о ваших развертываемых и стручках в Кубейнетах.

Получить все стручки:

Вы можете получить список всех запущенных стручков, используя команду kubectl Get Pods:

kubectl get pods

Выход должен выглядеть аналогично этому.

NAME                     READY   STATUS    RESTARTS   AGE
nginx-7654889675-zskr8   1/1     Running   0          4h29m

Получить подробное описание ваших стручков:

Если вы хотите более подробное описание ваших стручков, вы можете использовать команду «Описать команду PODS».

kubectl describe pods

Вывод:

Name:         nginx-674ff86d-88rj8
Namespace:    default
Priority:     0
Node:         node-3jis6/10.114.0.3
Start Time:   Fri, 24 Jul 2020 23:50:05 +0200
Labels:       app=nginx
              pod-template-hash=674ff86d
Annotations:  
Status:       Running
IP:           10.244.0.54
IPs:
  IP:           10.244.0.54
Controlled By:  ReplicaSet/nginx-674ff86d
Containers:
  nginx:
    Container ID:   docker://5e91ecc5134de36be301635efdccd1816da4506b33d339ea2e845334acd958e2
    Image:          nginx:latest
    Image ID:       docker-pullable://nginx@sha256:0e188877aa60537d1a1c6484b8c3929cfe09988145327ee47e8e91ddf6f76f5c
    Port:           
    Host Port:      
    State:          Running
      Started:      Fri, 24 Jul 2020 23:50:12 +0200
    Ready:          True
    Restart Count:  0
    Environment:    
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-dn7gb (ro)
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True
Volumes:
  default-token-dn7gb:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-dn7gb
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age        From                 Message
  ----    ------     ----       ----                 -------
  Normal  Scheduled    default-scheduler    Successfully assigned default/nginx-674ff86d-88rj8 to node-3jis6
  Normal  Pulling    16s        kubelet, node-3jis6  Pulling image "nginx:latest"
  Normal  Pulled     11s        kubelet, node-3jis6  Successfully pulled image "nginx:latest"
  Normal  Created    10s        kubelet, node-3jis6  Created container nginx
  Normal  Started    10s        kubelet, node-3jis6  Started container nginx

Просмотр журналов POD:

Информация, которую ваша приложение обычно отправит на STDOUT, станет журналами вашего контейнера. Вы можете получить доступ к этим журналам, используя следующую команду.

kubectl logs $POD_NAME

ПРИМЕЧАНИЕ. Вы можете получить имя вашего POD, используя либо Pods Pods, либо описать команду Pods.

Выполнение команды в контейнере:

Мы можем выполнить команды непосредственно в нашем контейнере, используя команду kubectl Exec, которая принимает имя POD и команду, которую мы хотим работать как аргументы.

kubectl exec $POD_NAME command

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

kubectl exec -it $POD_NAME bash

Обнаружение вашего приложения публично:

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

Создание услуги:

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

kubectl create service nodeport nginx --tcp=80:80

Это создаст услуги для нашего развертывания NGINX и разоблачить порт 80 нашего контейнера в порт на нашем хозяином машине.

Вы можете получить порт на хост-машина, используя Kubectl Получить услуги команда:

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)           AGE
kubernetes   ClusterIP   10.245.0.1              443/TCP           27h
nginx        NodePort    10.245.74.155           80:30392/TCP      8s

Как видите, порт 80 контейнера пересылается в порт 31041 моего хозяина. Когда у вас есть порт, вы можете проверить свое развертывание, посетив свой Localhost на этом порту.

Удаление услуги:

Мы также можем удалить существующие услуги, используя команду SELETE SERVICE.

kubectl delete service nginx

Расширяйте свое приложение:

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

kubectl scale deployments/nginx --replicas=5

Эта команда будет масштабировать нашу службу Nginx до пяти реплик.

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

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

Объявление объекта Kubernetes в Ямле

Каждый объект в Kubernetes можно представить в качестве декларативного объекта YAML, который предоставляет подробную информацию о том, что и как вы хотите запустить. Эти файлы часто используются для повышения повторного использования конфигурации ресурсов, таких как развертывание, обслуживание, объемы и многое другое.

Этот раздел покажет вам основы YAML и как вы можете получить список всех доступных параметров и атрибуты объекта Kubernetes. Мы также посмотрим на файл развертывания и обслуживания, чтобы получить лучшее ощущение синтаксиса и как вы можете развернуть файл.

Получение параметров различных объектов:

Есть много разных объектов Kubernetes, и все трудно запомнить все настройки. Именно здесь команда объяснения вступает в игру.

kubectl explain deployment

# Output
KIND:     Deployment
VERSION:  extensions/v1beta1

DESCRIPTION:
     DEPRECATED - This group version of Deployment is deprecated by
     apps/v1beta2/Deployment. See the release notes for more information.
     Deployment enables declarative updates for Pods and ReplicaSets.

FIELDS:
   apiVersion   
     APIVersion defines the versioned schema of this representation of an
     object. Servers should convert recognized schemas to the latest internal
     value, and may reject unrecognized values. More info:
     https://git.k8s.io/community/contributors/devel/api-conventions.md#resources

   kind 
     Kind is a string value representing the REST resource this object
     represents. Servers may infer this from the endpoint the client submits
     requests to. Cannot be updated. In CamelCase. More info:
     https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds

   metadata     
     Standard object metadata.

   spec 
     Specification of the desired behavior of the Deployment.

   status       
     Most recently observed status of the Deployment.

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

kubectl explain deployment.spec.replicas

Файл развертывания:

Более сложные развертывания обычно будут написаны в YAML для легкой повторного использования и изменчивости.

Вот основная структура файлов:

apiVersion: apps/v1
kind: Deployment
metadata:
  # The name and label of your deployment
  name: mongodb-deployment
  labels:
    app: mongo
spec:
  # How many copies of each pod do you want
  replicas: 3
  # Which pods are managed by this deployment
  selector:
    matchLabels:
      app: mongo
  # Regular pod configuration / Defines containers, volumes and environment variable 
  template:
    metadata:
      # label the pod
      labels:
        app: mongo
    spec:
      containers:
      - name: mongo
        image: mongo:4.2
        ports:
        - containerPort: 27017

Файл yaml имеет несколько важных разделов:

  • Apiversion — определяет версию API -Ind — Текущий объект Kubernetes, определенный в файле (например, развертывание, обслуживание, персистентВолит, …)
  • Метаданные — Описание вашего компонента YAML, содержащего имя, этикетки и другую информацию
  • SPEC — Определяет атрибут вашего развертывания E.G. реплики, Пределы ресурсов
  • Шаблон — Конфигурация POD файла развертывания

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

kubectl apply -f deploy.yaml

Сервисный файл:

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

apiVersion: v1
kind: Service
metadata:
  name: mongo
spec:
  selector:
    app: mongo
  ports:
    - port: 27017
      targetPort: 27017
  type: LoadBalancer

Место хранения

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

Есть несколько разных видов хранения:

  • Контейнерная файловая система — стандартное хранилище, которое хранит данные одного контейнера для его жизни
  • Объем — объемы позволяют сохранить данные и поделиться ею между различными контейнерами, пока POD существует
  • Настойчивые объемы — постоянные тома сохраняют данные даже после удаления POD или перезапуска. Это долгосрочное хранение в вашем кластере Kubernetes.

Объемы:

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

Существует два шага для использования объема в Kubernetes:

  • Стручок определяет громкость
  • Контейнер использует объемым объема для добавления громкости на определенный путь файловой системы

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

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
    volumeMounts:
    - name: nginx-storage
      mountPath: /etc/nginx
  volumes:
  - name: nginx-storage
    emptyDir: {}

Тег объема используется для определения тома, который затем может быть установлен в определенный каталог файловой системы контейнера (в этом случае/etc/nginx).

Стойкие объемы:

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

Наиболее распространенным способом определения постоянного тома является так называемой постоянным объектом претензий по тому (ПВХ), который соединяется с томами хранения Backend через серию абстракций.

Вот пример файла конфигурации YAML.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pv-claim
  labels:
    app: sampleAppName
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

Затем вы можете использовать свой ПВХ в вашу фактическое развертывание Kubernetes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
  labels:
    app: mysql
spec:
  selector:
    matchLabels:
      app: mysql
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
        tier: mysql
    spec:
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-password
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim

Есть больше способов сохранения ваших данных в Kubernetes и автоматизировать этот процесс как можно больше. Вот список нескольких интересных тем, на которых вы должны взглянуть.

Управляющие вычислительные ресурсы

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

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

Существует два различных типа спецификаций ресурсов, которые мы подробно опишем в следующих двух разделах.

Запросы:

Запросы рассказывают Kubernetes требования стручка и что ему следует разместить POD на узлы, которые имеют эти требования. Запросы определяются под тегом ресурсов на вашем контейнере.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongodb-deployment
  labels:
    app: mongo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
    spec:
      containers:
      - name: mongo
        image: mongo:4.2
        ports:
        - containerPort: 27017
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"

Ограничения:

Пределы ресурсов используются для ограничения памяти и использования CPU определенного стручка и обеспечивают максимальное значение ресурсов, которые POD никогда не может превышать.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongodb-deployment
  labels:
    app: mongo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
    spec:
      containers:
      - name: mongo
        image: mongo:4.2
        ports:
        - containerPort: 27017
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"

Для получения дополнительной информации о управлении вычислениями ресурсов посетите Официальная документация Отказ

Секреты

Secrets Kubernetes позволяют вам безопасно хранить и управлять конфиденциальными данными, такими как пароли, токены API или SSH-ключей.

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

  • В качестве файла в объеме, который установлен на контейнер
  • Использование переменной среды
  • Кублет при вытягивании изображения из частного реестра

Создание секрета:

Создание секретов может быть сделано либо с использованием командной инструмент KUBELT или определяя секретные объекты Kubernetes с использованием YAML.

Используя кублет:

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

kubectl create secret generic admin-credentials --from-literal=user=poweruser --from-literal=password='test123'

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

echo -n 'poweruser' > ./username.txt
echo -n 'test123' > ./password.txt
kubectl create secret generic admin-credentials--from-file=./username.txt --from-file=./password.txt

Вы также можете предоставить несколько файлов одновременно с помощью папки.

kubectl create secret generic admin-credentials --from-file=/creds

Использование файлов определения:

Как и другие объекты Kubernetes, секреты также могут быть определены с использованием файла YAML.

apiVersion: v1
kind: Secret
metadata:
  name: secret-apikey
data:
  apikey: YWRtaW4=

Секрет содержит ключ-значение вашей конфиденциальной информации с APIKEY, являющимся ключом и базовым декодированным значением.

Теперь вы можете создать секрет, используя команду Apply.

kubectl apply -f secret.yaml

Если вы хотите предоставить простые данные и позволять Kubernetes обрабатывать кодировку для вас, просто используйте атрибут StringData.

apiVersion: v1
kind: Secret
metadata:
  name: plaintext-secret
stringData:
  password: test

Использование секретов:

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

Переменные среды:

Секретные данные могут потребляться с использованием переменных среды в POD.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx
      image: nginx
      env:
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: secret-apikey
              key: apikey

Переменная среды может затем использоваться после того, как POD находится в рабочем состоянии.

kubectl exec nginx-pod -- env | grep API_KEY

Вы также можете использовать все записи в секрете, используя Engrame, что и передает секрет.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx
      image: nginx
      envFrom:
        - secretRef:
            name: secret

Объемы:

Секреты также могут быть установлены на POD, используя объем.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx
      image: nginx
      volumeMounts:
        - name: apikey-volume
          mountPath: /secret
          readOnly: true
  volumes:
    - name: apikey-volume
      secret:
        secretName: secret-apikey

Том Apikey относится к секретно-апикею. Мы также указываем каталог MountPath, что секрет будет храниться и настроен на retonly to true.

Imagepullsecrets:

При вытеснении от частного реестра вам может потребоваться аутентифицировать, прежде чем вытащить изображение. ImagePullSecrets — это файл, который хранит данные аутентификации и делает его доступным для всех ваших узлов, когда им нужно потянуть определенное изображение.

apiVersion: v1
kind: Pod
metadata:
  name: private-image
spec:
  containers:
    - name: privateapp
      image: gabrieltanner/graphqltesting
  imagePullSecrets:
    - name: authentification-secret

Дополнительная информация о частных реестрах Docker можно найти в Эта статья Отказ

Пространства имен

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

Управление и использование пространств имен с kubectl прямо вперед. Этот раздел продемонстрирует наиболее распространенные действия и команды, касающиеся пространств имен.

Просмотр существующих пространств имен:

Чтобы отобразить все доступное в настоящее время пространство имен вашего кластера, вы можете использовать команду kubectl Get Sastescates.

kubectl get namespaces

# Output
NAME                   STATUS   AGE
default                Active   32d
docker                 Active   32d
kube-public            Active   32d
kube-system            Active   32d

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

kubectl describe namespace default

# Output
Name:         default
Labels:       
Annotations:  
Status:       Active

No resource quota.

No resource limits

Создание пространства имен:

Пространства имен могут быть созданы либо с использованием KUBECTL CLI, либо путем создания объекта Kubernetes в YAML.

kubectl create namespace testnamespace

# Output
namespace/testnamespace created

Вот те же функциональность, используя файл yaml.

apiVersion: v1
kind: Namespace
metadata:
  name: testnamespace

Затем вы можете применить файл конфигурации, используя команду kubectl Apply.

kubectl apply -f testNamespace.yaml

Фильтрация по пространству имен:

При создании нового объекта в Kubernetes, не добавляя пользовательский атрибут пространства имен, он будет добавлен в пространство имен по умолчанию.

Если вы хотите создать свой объект в другом рабочем пространстве, вы можете сделать это так.

kubectl create deployment --image=nginx nginx --namespace=testnamespace

Теперь вы можете фильтровать для вашего развертывания, используя команду get.

kubectl get deployment --namespace=testnamespace

Изменить пространство имен, используя контекст:

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

Именно поэтому вы можете изменить контекст по умолчанию, что ваши команды будут применяться, используя команду set-context.

kubectl config set-context $(kubectl config current-context) --namespace=testnamespace

Вы можете проверить изменения, используя команду get-context.

kubectl config get-contexts

# Output
CURRENT   NAME      CLUSTER   AUTHINFO   NAMESPACE
*         Default   Default   Default    testnamespace

Упрощение Куберовщиков с помощью Docker Compose

Для тех из вас, кто выходит из сообщества Docker, может быть проще написать Docker Compose файлы вместо объектов Kubernetes. Вот где компенсирует в игру. Он позволяет преобразовать или развернуть файл Pocker-Compose в Kubernetes, используя простую CLI (интерфейс командной строки).

Установка компения:

Компоненты могут быть установлены на всех трех зрелых операционных системах очень простым и простым способом.

Пользователям Linux и Mac просто нужно закрутить двоичные файлы для установки комфорта.

# Linux
curl -L https://github.com/kubernetes/kompose/releases/download/v1.21.0/kompose-linux-amd64 -o kompose

# macOS
curl -L https://github.com/kubernetes/kompose/releases/download/v1.21.0/kompose-darwin-amd64 -o kompose

chmod +x kompose
sudo mv ./kompose /usr/local/bin/kompose

В Windows вы можете скачать исполняемый файл и просто запустить его.

Развертывание использования компения:

Компоненты принимают существующие пакетные файлы Docker и развертывают их в Kubernetes. Давайте посмотрим на пример, используя следующий файл COMPOSE.

version: "2"
services:
  redis-master:
    image: k8s.gcr.io/redis:e2e 
    ports:
      - "6379"
  redis-slave:
    image: gcr.io/google_samples/gb-redisslave:v1
    ports:
      - "6379"
    environment:
      - GET_HOSTS_FROM=dns
  frontend:
    image: gcr.io/google-samples/gb-frontend:v4
    ports:
      - "80:80"
    environment:
      - GET_HOSTS_FROM=dns
    labels:
      kompose.service.type: LoadBalancer

Как и в составке Docker, компон также позволяет развертывать нашу конфигурацию с помощью простой команды.

kompose up

Теперь вы должны увидеть созданные ресурсы.

kubectl get deployment,svc,pods,pvc

Преобразование файла Compose на объекты Kubernetes:

Компон также имеет возможность преобразовать существующий Docker Compose файл в связанные объект Kubernetes.

kompose convert

Затем вы можете развернуть ваше приложение, используя команду Apply.

kubectl apply -f filenames

Развертывание демонстрации демонстрации

Теперь, когда вы знаете теорию и все жизненно важные концепции Куберанес, настало время на практике привести к этой практике. Эта глава покажет вам, как вы можете развернуть приложение Backend на Kubernetes.

Специфическое применение в этом руководстве представляет собой бойную табличку GraphQL для BackeND Backend.

Давайте начнем с клонирования репозитория.

git clone https://github.com/TannerGabriel/nestjs-graphql-boilerplate.git

Нажатие изображений в реестр:

Прежде чем мы сможем начать с создания объектов Kubernetes, нам сначала нужно нажать изображения в общедоступный реестр изображения. Это может быть либо публичным реестром, таким как DockerHub или ваш собственный частный реестр.

Если вы хотите узнать больше о том, как настроить свой собственный Private Docker Image, посетите Эта статья Отказ

Чтобы нажать изображение, просто добавьте тег изображения с реестром, который вы хотите нажать в свой файл Compose.

version: '3'

services:
  nodejs:
    build:
      context: ./
      dockerfile: Dockerfile
    image: gabrieltanner.dev/nestgraphql
    restart: always
    environment:
      - DATABASE_HOST=mongo
      - PORT=3000
    ports:
      - '3000:3000'
    depends_on: [mongo]
  mongo:
    image: mongo
    ports:
      - '27017:27017'
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data: {}

Я лично использовал частный реестр, который я настроил ранее, но вы можете просто использовать Dockerhub.

Создание объектов Kubernetes:

Теперь, когда вы нажали свое изображение в реестр, давайте продолжим, написав наши объекты Kubernetes.

Во-первых, создайте новый каталог для хранения развертываний.

mkdir deployments
cd deployments

touch mongo.yaml
touch nestjs.yaml

Услуги и развертывание MongoDB тогда выглядят так.

apiVersion: v1
kind: Service
metadata:
  name: mongo
spec:
  selector:
    app: mongo
  ports:
    - port: 27017
      targetPort: 27017
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongo
spec:
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
    spec:
      containers:
        - name: mongo
          image: mongo
          ports:
            - containerPort: 27017

Файл содержит объект развертывания с одним контейнером MongoDB, который помечен Mongo. Он также содержит услугу, которое делает порт 27017, доступный для сети Kubernetes (ее нельзя доступ к хосту, но только из других контейнеров в том же пространстве имен).

Объект Nest.js Kubernetes немного сложнее, потому что контейнер нуждается в некоторой дополнительной конфигурации, такой как переменные среды и ImagePullSecrets.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nestgraphql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nestgraphql
  template:
    metadata:
      labels:
        app: nestgraphql
    spec:
      containers:
        - name: app
          image: "gabrieltanner.dev/nestgraphql"
          ports:
            - containerPort: 3000
          env:
            - name: DATABASE_HOST
              value: mongo
          imagePullPolicy: Always
      imagePullSecrets:
            - name: regcred
---
apiVersion: v1
kind: Service
metadata:
  name: nestgraphql
spec:
  selector:
    app: nestgraphql
  ports:
    - port: 80
      targetPort: 3000
  type: LoadBalancer

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

Развертывание приложения:

Теперь, когда объектные файлы Kubernetes готовы к работе, давайте разверним их с помощью kubectl.

kubectl apply -f mongo.yaml
kubectl apply -f nestjs.yaml

Теперь вы должны иметь возможность получить доступ к игровой площадке GraphQL на localhost/graphql.

Поздравляем, вы только что развернули ваше первое заявление на Kubernetes.

Источники

Вот список источников, которые я использовал для этой статьи:

Вывод

Вы сделали это до конца до конца! Я надеюсь, что эта статья помогла вам понять Kubernetes и как вы можете использовать его для улучшения рабочего процесса вашего разработки и развертывания в качестве разработчика.

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

Первоначально опубликовано в gabrieltanner.org.

Оригинал: «https://dev.to/gabrieltanner/the-definitive-guide-to-kubernetes-21d7»