Tekton

Начни новое:

• 29 июля, 2020 Master Course: Tekton Pipelines
  Как автоматизировать ваш end-to-end pipeline от code commit, через docker build, к запуску в кластере с (Kubernetes-native Pipelines).
• Книга Kubernetes Patterns можно качать
  Современные архитектуры требуют современного набора шаблонов и практик. Научитесь использовать паттерны конфигурации к приложениям на основе Kubernetes с нашей бесплатной электронной книгой Kubernetes Patterns.
• Улучшенный XML grammar binding и кое-что еще в Red Hat VS Code XML extension 0.13.0
  Вкусный extension Red Hat XML для VS Code 0.13.0, оснащенный улучшенной способностью связывать и генерировать новый XSD или DTD grammar file из существующего файла XML и многое другое.
• Опять про Nasa AI seeks ET: Сможет ли машинное обучение найти жизнь в Солнечной Системе
  
  
  
  
  
• Создание, сохранение и загрузка container images при помощи Ansible

Строй:

• Шок-контент! Разработчик целый месяц не использовал Debugger!
  Узнайте у разработчика, который не использовал debugger в течение месяца, как улучшить код, а не полагаться на инструменты отладки.
  
  
  
  
  
• Более Лучше производительность и юзабилити в Red Hat CodeReady Workspaces 2.2
  Red Hat CodeReady Workspaces 2.2 принес с собой улучшения производительности и конфигурации, debug mode для рабочих пространств и ограничения CPU для плагинов IDE.
• Оптимизация по профилю в Clang: работа с модифицированными источниками
  Разбираем кейс из реального мира real-world bug, который показывает подводные камни текущего подхода к PGO. А потом рассказываем как компилятор Clang реализует оптимизацию на основе профилей.
• Автоматические Grafana metrics dashboards для приложений MicroProfile
  Как использовать MicroProfile Metrics Generator для динамического создания единой панели мониторинга со всеми метриками проекта в одном месте.

Пообщаться:

• 23 июля, Tech Talk @ 19:00 по Нижнему Новгороду: Secure Vue.js apps with Keycloak
  Поддерживайте свои требования к безопасности с помощью простого комплексного all-in-one интегрированного решения для защиты веб-приложений и их вспомогательных сервисов с помощью Keycloak.
• 30 июля, Tech Talk @ 19:00 по Краснодарскому времени: Developer joy for distributed teams with CodeReady Workspaces
  Начните писать и тестировать изменения в Kubernetes-containerized средах (рабочих пространствах) и развертывать приложения, удобно используя CodeReady Workspaces.

По-русски:

В недавней статье выдвинуто предложение использовать Tekton в качестве фреймворка для облачных пайплайнов CI/CD и Argo CD в качестве идеальной пары для GitOps. Методики GitOps поддерживают непрерывное развертывание в гибридных и мультикластерных средах Kubernetes.

В настоящей статье, состоящей из двух частей, мы построим рабочий поток CI/CD, который продемонстрирует возможности совместного использования Tekton и GitOps. Вы также познакомитесь с Red Hat OpenShift Serverless, так как мы будем использовать ресурсы сервисов Knative в нашем CI/CD процессе. Начнем же мы с обзора процесса CI/CD, который мы внедрим для примера.

CI/CD процесс

На схеме ниже изображен CI/CD процесс. Коммит, инициированный в исходном коде приложения, запускает полный CI/CD процесс, который завершается тем, что новая версия бессерверного приложения развертывается в Dev, Stage и Prod средах.

Рисунок 1. Демонстрационный пример CI/CD процесса.

Давайте подробнее рассмотрим каждый шаг этого процесса:

1. Разработчик отправляет новое изменение в репозиторий исходного кода приложения.
2. Созданный в репозитории исходного кода вебхук запускает пайплайн Tekton.
3. Как только пайплайн запустился, первая задача вызывает исходный код из репозитория.
4. Задача Maven упаковывает код приложения в файл JAR и проводит тесты модулей до того, как построить образ контейнера.
5. Задача Buildah строит и отправляет образ контейнера в registry. И затем образ отправляется во внутренний registry OpenShift.
6. Пайплайн обновляет у себя репозиторий, в котором хранится желаемое состояние конфигурации приложения и описание развертывания. В методологии GitOps мы используем репозиторий Git в качестве единственного источника истины о том, что и куда развертывается.
7. Изначально Git-репозиторий может быть пуст, но это не проблема, и этот шаг, инициализирует репозиторий со всеми манифестами Kubernetes (в данном случае сервисы Knative и ConfigMaps), которые необходимы, чтобы впервые запустить приложение. Последующие коммиты репозитория будут лишь обновлять существующие дескрипторы новыми версиями приложения, настройки канареечного тестирования и связанные конфигурации. Как только все файлы манифеста были созданы или модифицированы, задача отправляет изменения в репозиторий. Этот шаг является связующим звеном между непрерывной интеграцией, производимой пайплайном Tekton, и непрерывным развертыванием, управляемым Argo CD.
8. Argo CD извлекает из репозитория конфигурации и синхронизирует существующие манифесты Kubernetes, которые заданы файлами Kustomize. Это действие создает последние объекты Kubernetes в неймспейсах development, stagingи production. Синхронизация может производиться автоматически или вручную в зависимости от требований неймспейса.
9. В финальной части процесса может понадобиться извлечь образы, на которые ссылались в развертывании манифеста Kubernetes из внутреннего registry OpenShift. Команда эксплуатации может также внести изменения в конфигурацию, например, сменив URL целевого микросервиса или определенную информацию, которая известна команде разработчиков. Последний шаг может также создать состояние OutOfSync, что приведет к новому процессу синхронизации (см. шаг 9 на схеме).

Далее мы настроим наш кластер с OpenShift Operators и сервисами, которые нам понадобятся.

Настройка кластера OpenShift

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

$ git clone https://github.com/dsanchor/rh-developers-cicd.git

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

• Helm: helm version
• Git: git version
• oc: oc version
• kustomize не ниже v3.1.0: customize version
• envsubst (gettext): envsubst --help
• tkn (опционально Tekton CLI): tkn version

Проверив все вышеуказанные требования, залогиньтесь в ваш кластер OpenShift под пользователем с правами администратора кластера:

$ oc login -u USERNAME -p PASSWORD https://api.YOUR_CLUSTER_DOMAIN:6443

Операторы, неймспейсы и привязки ролей

Мы сначала установим OpenShift Pipelines и OpenShift Serverless операторов в неймспейс openshift-operators.

Также создадим четыре новых неймспейса: cicd, development, staging и production. Образы помещаются в границы неймспейса cicd, поэтому, чтобы получать новые образы, все остальные неймспейсы требуют привилегий system:image-puller.

Наконец, добавим новую роль view по умолчанию в сервисные аккаунты development, staging и production. Эта роль обеспечивает доступ из наших подов приложения Quarkus к ConfigMaps и Secrets. (Приложение Quarkus я представлю чуть-чуть попозже).

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

$ ./bootstrap.sh---------------Installing openshift-pipelines operatorRelease "openshift-pipelines" does not exist. Installing it now.NAME: openshift-pipelinesLAST DEPLOYED: Thu Sep 10 10:55:14 2020NAMESPACE: defaultSTATUS: deployedREVISION: 1TEST SUITE: NoneInstalling openshift-serverlessRelease "openshift-serverless" does not exist. Installing it now.NAME: openshift-serverlessLAST DEPLOYED: Thu Sep 10 10:55:16 2020NAMESPACE: defaultSTATUS: deployedREVISION: 1TEST SUITE: NoneCreating cicd, development, staging and production namespacesAdded cicd system:image-puller role to default sa in development, staging and production namespacesAdded view role to default sa in development, staging and production namespacesRelease "bootstrap-projects" does not exist. Installing it now.NAME: bootstrap-projectsLAST DEPLOYED: Thu Sep 10 10:55:18 2020NAMESPACE: defaultSTATUS: deployedREVISION: 1TEST SUITE: None

Вы можете выполнить скрипты как есть или использовать чарты Helm независимо, переопределяя любые значения на ваш выбор. Например, вы можете переопределить значение канала подписки для каждого оператора OpenShift.

Рисунок 2 показывает текущее состояние установки: оба оператора установлены в неймспейсе openshift-operators.

Рис. 2. Операторы OpenShift Serverless и OpenShift Pipelines установлены в неймспейсе openshift-operators.

Проверьте, что OpenShift Pipelines Operator установлен не ниже версии 1.1.1.
Теперь завершим установку компонентов OpenShift Serverless, установив панель управления Knative Serving.

Установка экземпляра Knative Serving

Нам нужно установить экземпляр Knative Serving, который предоставит нашим приложениям набор бессерверных возможностей. Чтобы создать экземпляр Knative Serving и установить панель управления, выполните следующее:

$ ./add-knative-serving.sh------------------------------Creating knative-serving namespacenamespace/knative-serving createdInstalling basic knative serving control planeknativeserving.operator.knative.dev/knative-serving created

Мы запустили набор подов, которые представляют базовую контрольную панель Knative Serving в неймспейс knative-serving, как показано на Рисунке 3.

Рис. 3. Панель управления Knative Serving в неймспейсе knative-serving.

Как показано на Рисунке 4, мы также создали новый неймспейс knative-serving-ingress для установочных входных шлюзов Knative.

Рис. 4. Новый неймспейс knative-serving-ingress.

Мы установили операторов OpenShift и создали неймспейс и экземпляр Knative Serving для управления нашими бессерверными процессами. Теперь мы готовы создать ресурсы Tekton, которые нам понадобятся для запуска пайплайна непрерывной интеграции.

Настройка задач и пайплайна Tekton

OpenShift Pipelines Operator поставляется с набором готовых кластерных задач, которые можно использовать для создания пайплайна. В некоторых ситуациях вам понадобятся другие задачи для получения определенного функционала. Эти задачи можно легко создать в Tekton. Вы также можете найти повторно используемые задачи и готовые пайплайны на Tekton Hub.

Для нашего пайплайна мы будем использовать одну задачу из Tekton Hub и две пользовательские. Чтобы эти задачи были доступны нашему пайплайну, нам нужно создать их в неймспейсе cicd. (Обратите внимание, что вы можете создать ClusterTasks, если считаете, что повторно используете их в разных пайплайнах из разных неймспейсов). Запустите следующий скрипт, чтобы установить необходимые задачи и создать пайплайн в том же неймспейсе.

$ ./add-tekton-customs.sh cicd------------------------------Installing buildah task from https://hub-preview.tekton.dev/task.tekton.dev/buildah createdInstalling custom taskstask.tekton.dev/push-knative-manifest createdtask.tekton.dev/workspace-cleaner createdInstalling knative-pipelinepipeline.tekton.dev/knative-pipeline created

Перейдите в консоль OpenShift и откройте меню Pipelines и проект cicd. Там вы увидите свои новые задачи, как показано на Рисунке 5.

Рис. 5. Новые задачи Tekton в неймспейсе cicd.

На Рисунке 6 представлен ваш новый пайплайн в том же неймспейсе.

Рис. 6. Пайплайн Tekton в неймспейсе cicd.

Рабочие области Tekton

Некоторые наши задачи в пайплайне требуют либо загрузки определенных конфигураций из ConfigMaps, либо сохранения состояния полученного выполнения, чтобы разделить его с другими задачами. Например, задача Maven требует, чтобы мы включили определенный settings.xml в ConfigMap. С другой стороны, первая задача вызывает репозиторий исходного кода приложения. Задаче Maven, которая идет следующей, потребуются эти файлы, чтобы создать приложение JAR. Мы используем OpenShift PersistentVolume, чтобы поделиться этими исходными файлами.

Tekton для этих целей имеет концепцию рабочих областей. Запустите следующий скрипт, чтобы добавить набор ConfigMaps и PersistentVolumeClaim в неймспейс cicd:

$ ./add-tekton-workspaces.sh cicd-----------------------------------Creating knative-kustomize-base ConfigMap with base kustomize files for Knative servicesconfigmap/knative-kustomize-base createdCreating knative-kustomize-environment ConfigMap with environment dependent kustomize filesconfigmap/knative-kustomize-environment createdCreating maven ConfigMap with settings.xmlconfigmap/maven createdCreating PVC using default storage classpersistentvolumeclaim/source-pvc created

Заметьте, этот скрипт создает PersistentVolumeClaim, не определяя StorageClass. Если вы не выберете какой-то определенный, то будет использоваться StorageClass по умолчанию. Без проблем можете раскомментировать любые строки в этом скрипте, чтобы он удовлетворял вашим требованиям.

Демо-приложение

До сих пор я почти ничего не сказал о демо-приложении. Оно основано на Quarkus, который идеально подходит для бессерверных приложений благодаря короткому времени загрузки и низкому потреблению памяти. Само приложение представляет из себя простой REST API Hello, world, который приветствует пользователей при вызове URI /hello.

Приложение использует расширение kubernetes-config для того, чтобы упростить работу с ConfigMaps и Secrets в Kubernetes. Приложение Hello, world! читает список ConfigMaps, что дает нам возможность управлять конфигурацией на разных уровнях, отменяя дублируемые свойства.

Рисунок 7 показывает фрагмент application.yaml, который определяет список ConfigMaps.

Рис. 7. Приложение YAML со списком ConfigMaps.

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

Создание собственного репозитория

На данном этапе вы должны создать репозиторий GitHub, который вы будете использовать для хранения файлов кастомизации, которые необходимы для демонстрации. Мой репозиторий называется quarkus-hello-world-deployment, и я буду использовать это имя для отсылок к данному репозиторию в следующих скриптах. Вы можете взять то же самое имя или придумать репозиторию свое.

GitHub изменил имя по умолчанию на main, что видно на Рисунке 8.

Рис. 8. Main задан веткой по умолчанию.

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

Чтобы пайплайн Tekton мог отправлять изменения в новый репозиторий, вам нужно будет предоставить валидные учетные данные GitHub. Учетные данные вы сохраните в Secret и свяжете их с пайплайном ServiceAccount, который был автоматически создан в неймспейсе cicd.

Запустите следующий скрипт:

$ ./add-github-credentials.sh cicd YOUR_GITHUB_USER YOUR_GITHUB_PASSWORD---------------------------------------------------------------------------Creating secret with github credentials for user dsanchorsecret/github-credentials createdLinking pipeline sa in namespace cicd with your github credentialsserviceaccount/pipeline patched

Ручной запуск пайплайна

Теперь мы готовы к тому, чтобы вручную протестировать работу пайплайна и увидеть результаты. Рабочий процесс пайплайна включает настройку вебхука, который автоматически запускает пайплайн. Описание этого этапа мы оставим на конец этой статьи (см. Часть 2). На данный момент просто протестируем рабочий процесс, запустив пайплайн вручную.

Я написал два варианта запуска пайплайна вручную:

• Создать пайплайн из yaml-файла;
• Запустить пайплайн, используя Tekton CLI: tkn.

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

$ cat tekton/pipelines/knative-pipeline-run.yaml | \  SOURCE_REPO=https://github.com/dsanchor/quarkus-hello-world.git \  COMMIT=9ce90240f96a9906b59225fec16d830ab4f3fe12 \  SHORT_COMMIT=9ce9024 \  DEPLOYMENT_REPO=https://github.com/dsanchor/quarkus-hello-world-deployment.git \  IMAGES_NS=cicd envsubst | \  oc create -f - -n cicd------------------------------------------------------------------------------------------pipelinerun.tekton.dev/knative-pipeline-run-54kpq created

Если вы предпочитаете второй вариант, можно запустить пайплайн через tkn CLI:

$ tkn pipeline start knative-pipeline -p application=quarkus-hello-world \  -p source-repo-url=https://github.com/dsanchor/quarkus-hello-world.git \  -p source-revision=9ce90240f96a9906b59225fec16d830ab4f3fe12 \  -p short-source-revision=9ce9024 \  -p deployment-repo-url=https://github.com/dsanchor/quarkus-hello-world-deployment.git \  -p deployment-revision=master \  -p dockerfile=./src/main/docker/Dockerfile.jvm \  -p image-registry=image-registry.openshift-image-registry.svc.cluster.local:5000 \  -p image-repository=cicd \  -w name=source,claimName=source-pvc \  -w name=maven-settings,config=maven \  -w name=knative-kustomize-base,config=knative-kustomize-base \  -w name=knative-kustomize-environment,config=knative-kustomize-environment \  -n cicd

Еще один вариант запустить пайплайн через консоль OpenShift.

Отслеживание работы пайплайна

Для проверки рабочего прогресса откройте панель Pipeline Runs на консоли OpenShift, как показано на Рисунке 9.

Рис. 9. Использование панели Pipeline Runs для проверки рабочего прогресса.

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

Рис.10. Просмотр логов каждой задачи пайплайна.

Если вдруг вы дважды запустите пайплайн с одними и теми же параметрами (например, используя оба примера, которые я описал), вы увидите, что второй запуск завершится ошибкой при отправке манифестов Kustomization. Ошибка происходит, потому что нет ничего нового для выполнения отлично!

Результаты работы пайплайна

Диаграмма на Рисунке 11 иллюстрирует, чего мы уже достигли:

Рис. 11. Выполнение процесса CI/CD.

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

На данный момент мы уже отправили новый образ во внутренний registry OpenShift. Мы также запустили репозиторий, который будет содержать все манифесты конфигурации и развертывания вместе со всеми манифестами Kubernetes, которые требуются для запуска первой версии нашего бессерверного приложения.

Обзор структуры репозитория развертывания

Сейчас самое время для обзора структуры репозитория развертывания и того, что в итоге станет окончательными манифестами, которые мы создадим с помощью Kustomize. Если вы не знакомы с Kustomize и его возможностями, не стесняйтесь узнать о нем больше. Понимание Kustomize может помочь лучше разбираться в структуре репозитория.
Обновите репозиторий развертывания (git pull), вы должны увидеть похожий результат:

 base    global-ops-configmap.yaml    kservice.yaml    kustomization.yaml development    env-ops-configmap.yaml    kustomization.yaml    r9ce9024       configmap.yaml       revision-patch.yaml       routing-patch.yaml    traffic-routing.yaml production    env-ops-configmap.yaml    kustomization-r9ce9024.yaml    r9ce9024       configmap.yaml       revision-patch.yaml       routing-patch.yaml    traffic-routing.yaml README.md staging env-ops-configmap.yaml kustomization-r9ce9024.yaml r9ce9024    configmap.yaml    revision-patch.yaml    routing-patch.yaml traffic-routing.yaml

Для простоты я пока рассмотрю только папки base и development:

• Папка base содержит все ресурсы, общие для трех сред. В ней есть базовая структура сервиса Knative и карта глобальной конфигурации.
• Папка development содержит наложения для завершения генерации манифеста сервиса Knative в данной версии приложения (примером служит папка r9ce9024) и двух ConfigMap, связана с уровнем настроек самого окружения и уровнем настроек разработчика. То, что находится в папке ревизии, было скопировано из исходного кода приложения, что позволяет разработчику самому задавать гибкие настройки.

Мы пользуемся простотой сервисов Knative, чтобы определить независимые маршруты для каждой версии сервиса и распределить трафик между версиями. Таким образом, traffic-routing.yaml и routing-patch.yaml формируют окончательную секцию маршрутизации трафика сервиса Knative.

Каждый раз когда в development появляется новая версия, для нее создается независимый маршрут, чтобы она точно была доступна для тестирования. Основной маршрут остается неизменным (например, направленный на две предыдущие версии). Мы достигаем такого поведения не путем изменения основного traffic-routing.yaml автоматически из пайплайна, а благодаря добавлению нового маршрута (routing-patch.yaml) для новой версии.

Эти детали станет проще понимать, когда мы проведем дополнительные тесты в Части 2. На данный момент просто отметьте для себя существенную разницу между неймспейсами staging и production и средой development. Пайплайн CI не создает файл kustomization.yaml (именно с таким именем) для них. Всегда будет файл с дополнительным префиксом версии: kustomization-r9ce9024.yaml. Эти изменения не будут учитываться в процессе синхронизации, если только в kustomization.yaml нет отсылки на эту новую версию. Чтобы изменения стали видны Kustomize, это надо настроить вручную.

Примечание: Суть различий в именах файлов заключается в том, чтобы лучше различать наши демо-окружения. Я хотел, чтобы эти две среды вели себя по-разному, чтобы требовалось одобрение изменений от кого-то. Переименование файла простой подход к одобрению, который не делает демонстрацию слишком сложной. Я бы предпочел создавать отдельную ветку для каждой новой версии, а потом генерировать pull request, когда в ней завершена работа.

Kustomize: соберем все кусочки пазла вместе

Мы рассмотрели наполнение и структуру репозитория развертывания, но у нас до сих пор нет окончательной композиции сервиса Knative и ConfigMaps. Приведенный ниже скрипт использует kustomize для построения окончательных манифестов, чтобы мы смогли увидеть, как они выглядят:

$ kustomize build development------------------------------apiVersion: v1kind: ConfigMapmetadata:  name: env-ops-quarkus-hello-world---apiVersion: v1kind: ConfigMapmetadata:  name: global-ops-quarkus-hello-world---apiVersion: v1data:  application.yaml: |-    message: hola    environment:      name: devkind: ConfigMapmetadata:  name: quarkus-hello-world---apiVersion: serving.knative.dev/v1kind: Servicemetadata:  name: quarkus-hello-worldspec:  template:    metadata:      name: quarkus-hello-world-r9ce9024    spec:      containers:      - image: image-registry.openshift-image-registry.svc.cluster.local:5000/cicd/quarkus-hello-world:9ce90240f96a9906b59225fec16d830ab4f3fe12        livenessProbe:          httpGet:            path: /health/live        readinessProbe:          httpGet:            path: /health/ready  traffic:  - percent: 100    revisionName: quarkus-hello-world-r9ce9024  - revisionName: quarkus-hello-world-r9ce9024    tag: r9ce9024

Заключение

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

От редакции: Узнать о внедрении CI/CD и интеграции Gitlab CI с Kubernetes можно с помощью практического видеокурса Слёрма. На уроках курса инженеры компаний Tinkoff и Southbridge делятся лучшими практиками построения пайплайнов.

В первой части статьи я представил Tekton в качестве фреймворка для облачных пайплайнов CI/CD и Argo CD в качестве идеальной пары для GitOps в Red Hat OpenShift. Наша цель создать законченный процесс непрерывной интеграции и доставки, который начнется при коммите в репозитории GitHub и завершится, когда новое приложение будет развернуто в Dev, Staging и Prod средах.

В первой части мы использовали Tekton для реализации задач непрерывной интеграции (CI). Теперь мы завершим процесс CI/CD, реализовав задачи непрерывного развертывания (CD) с помощью Argo CD. Давайте посмотрим на схему на Рисунке 1, чтобы освежить в памяти процесс CI/CD.

Рис.1. Пример процесса CI/CD.

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

Во второй части мы воспользуемся возможностями Argo CD для полной автоматизации процесса развертывания приложения. Argo CD извлекает все изменения из файлов Kustomize, которые были отправлены в репозиторий развертывания пайплайном CI, и синхронизирует эти изменения в целевых неймспейсах. На последнем этапе нашей автоматизации мы напишем Tekton Trigger, который запустит весь процесс CI/CD.

Начало работы с Argo CD

Argo CD сейчас набирает популярность. Будучи первоклассным представителем экосистемы Kubernetes, он упрощает освоение GitOps, где команды используют декларативные описания конфигурации и инфраструктуры из Git в качестве единственного источника истины. Мы уже разработали задачи Tekton для нашего процесса CI/CD. Может ли Argo CD стать тем идеальным компонентом, которого сейчас не хватает в нашем процессе?

Установка Argo CD

Откройте веб-консоль OpenShift и перейдите в неймспейс cicd к нашему демонстрационному процессу. Используйте следующий скрипт, чтобы установить Argo CD Operator:

$ ./bootstrap-argo.sh cicd------------------------------Installing argo operatorRelease "argocd" does not exist. Installing it now.NAME: argocdLAST DEPLOYED: Thu Sep 10 18:37:23 2020NAMESPACE: defaultSTATUS: deployedREVISION: 1TEST SUITE: None

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

Рис. 2: Argo CD установлен в неймспейс проекта CICD.

Создание экземпляра Argo CD

Далее создадим экземпляр Argo CD. Этот экземпляр будет управлять всеми AppProjects и Applications, которые мы создали в неймспейсе cicd. Скрипты, приведенные ниже, создают следующее:

• Экземпляр Argo CD в неймспейсе cicd.
• AppProject под названием rh-developers.
• Три приложения в AppProject rh-developers. Каждое приложение ссылается на репозиторий развертывания в ветке master. Приложения синхронизированы с папками development, staging и production соответственно.

Выполните следующее (не забудьте использовать собственный репозиторий quarkus-hello-world-deployment):

$ ./add-argo-apps.sh cicd rh-developers https://github.com/dsanchor/quarkus-hello-world-deployment.git master----------------------------------------------------------------------------------------------------------------Installing basic Argo CD server instanceargocd.argoproj.io/argocd createdAdding edit role to argocd-application-controller ServiceAccount in projects development, staging and productionrolebinding.rbac.authorization.k8s.io/edit-rh-developers-dev createdrolebinding.rbac.authorization.k8s.io/edit-rh-developers-staging createdrolebinding.rbac.authorization.k8s.io/edit-rh-developers-production createdCreating rh-developers AppProject in namespace cicdappproject.argoproj.io/rh-developers createdCreating Applications in namespace cicd in rh-developers AppProjectapplication.argoproj.io/quarkus-hello-world-development createdapplication.argoproj.io/quarkus-hello-world-staging createdapplication.argoproj.io/quarkus-hello-world-production created

Пропишите маршрут для Argo CD, который вам нужен для доступа к главной панели управления Argo CD:

$ oc get routes argocd-server -n cicd---------------------------------------NAME            HOST/PORT                                             PATH   SERVICES        PORT    TERMINATION            WILDCARDargocd-server   argocd-server-cicd.apps.ocp4.mydomain.com          argocd-server   https   passthrough/Redirect   None

Дождитесь, пока запустится сервер Argo CD, затем авторизуйтесь, используя свои данные OpenShift. И вуаля! Вы должны получить текущий статус ваших приложений, как показано на Рисунке 3.

Рис 3: Войдите в панель управления Argo CD для просмотра всех версий приложений и их соответствующих рабочих статусов.

Примечание: Вы можете заметить, что и приложение development, и приложение staging показывают свой статус как Synced, а приложение production OutOfSync. Первые два сконфигурированы с активированной функцией автосинхронизации, а для production мы используем ручную конфигурацию.

Запуск первой версии приложения

В следующих нескольких разделах мы проведем пару ревизий нашего приложения quarkus-hello-world на этапах development, staging и production цикла развертывания. Информацию о приложении Quarkus, которое мы используем для этого примера, вы можете прочитать в первой части этой статьи.

Первая версия приложения в среде development

Кликните на приложение quarkus-hello-world-development и увидите, что каждый объект в этой версии был синхронизирован, как показано на Рисунке 4.

Рисунок 4: Кликните на версию приложения, чтобы проверить его рабочий статус.

То, что все объекты синхронизированы, означает, что первая версия приложения была успешно развернута. Теперь получите маршруты, чтобы мы могли иметь доступ к сервису (обратите внимание, что маршруты для сервисов Knative автоматически создаются в неймспейсе knative-serving-ingress):

$ oc get routes -n knative-serving-ingress | grep development--------------------------------------------------------------route-e387d9ca-9f1b-4c15-9b83-7bea4d2d290c-313361326363   quarkus-hello-world-development.apps.ocp4.mydomain.com                   kourier    http2   edge/Allow    Noneroute-e387d9ca-9f1b-4c15-9b83-7bea4d2d290c-613962613835   r9ce9024-quarkus-hello-world-development.apps.ocp4.mydomain.com          kourier    http2   edge/Allow    None

Команда get routes должна выдать, как минимум, два маршрута: основной маршрут (quarkus-hello-world-development.apps.ocp4.mydomain.com) и один для новой версии, которую мы только что развернули (r9ce9024-quarkus-hello-world-development.apps.ocp4.mydomain.com). Обратите внимание, что основной маршрут может иметь за собой несколько версий, но, поскольку это наше первое развертывание, за ним закреплена только одна.

Протестируем оба маршрута и посмотрим на результаты. Если ни один под не работает, это происходит, потому что Knative уменьшает размер неактивных подов. Первый запрос может занять больше времени, чем обычно, если приходится создавать под заново.
Добавьте /hello, затем используйте curl, чтобы протестировать эндпоинт:

$ curl http://quarkus-hello-world-development.apps.ocp4.mydomain.com/hellohola dev! Yeap!$ curl http://r9ce9024-quarkus-hello-world-development.apps.ocp4.mydomain.com/hellohola dev! Yeap!

Теперь вы можете перейти в меню Serverless веб-консоли OpenShift, выбрать проект development и рассмотреть его, как показано на Рисунке 5.

Рис 5: Просмотрите проект development в меню OpenShift Serverless.

Первая версия приложения в среде staging

Снова зайдите в панель управления Argo CD и взгляните на приложение staging. Вы должны увидеть единственный файл ConfigMap, который показан на Рисунке 6.

Рис. 6: Посмотрим на приложение staging в панели управления Argo CD.

У нас есть только ConfigMap, потому что мы еще не создали kustomization.yaml. Возможно, вы помните из первой части статьи, что у нас есть файл под названием kustomization-REVISION.yaml. Чтобы синхронизировать изменения с файлом REVISION, нужно переименовать этот файл и отправить изменения в Git.
Перейдите в папку, где вы проверяли репозиторий развертывания и запустите:

$ git pull && \mv staging/kustomization-r9ce9024.yaml staging/kustomization.yaml && \git add  staging && git commit -m "Revision 9ce9024 is now active in staging" && \git push

Подождите пару минут, чтобы Argo CD синхронизировал все изменения. Если не терпится, можно нажать Sync, чтобы версия автоматически запустилась в staging, как показано на Рисунке 7.

Рис. 7: Argo CD синхронизирует и развертывает изменения, которые вы только что внесли.

Точно так же, как мы делали с приложением development, получите маршруты и проведите несколько тестов

$ oc get routes -n knative-serving-ingress | grep staging------------------------------------------------------------route-fd38a613-ea42-4809-af13-cd02503980bf-346238393864   quarkus-hello-world-staging.apps.ocp4.mydomain.com                       kourier    http2   edge/Allow    Noneroute-fd38a613-ea42-4809-af13-cd02503980bf-623763373761   r9ce9024-quarkus-hello-world-staging.ocp4.mydomain.com              kourier    http2   edge/Allow    None$ curl http://quarkus-hello-world-staging.apps.ocp4.mydomain.com/hellohola staging! Yeap!$ curl http://r9ce9024-quarkus-hello-world-staging.apps.ocp4.mydomain.com/hellohola staging! Yeap!

Первая версия приложения в среде production

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

Рис. 8: Объекты в среде production должны быть синхронизированы вручную.

Чтобы новая версия приложения стала доступна для синхронизации, нам нужно одобрить это вручную. Проведите те же самые действия, что и для приложения в staging:

$ git pull && \mv production/kustomization-r9ce9024.yaml production/kustomization.yaml && \git add production && git commit -m "Revision 9ce9024 is now ready to be sync in production" && \git push

Через одну-две минуты вы увидите новые объекты, которые в данный момент помечены как OutOfSync, что видно на Рисунке 9.

Рис. 9: Добавьте новые объекты для текущего пересмотра и подтвердите действие на консоли Argo CD.

Если изменения совпадают с вашими ожиданиями, вы можете провести ручную синхронизацию, чтобы запустить новую версию в production. Нажмите кнопку Sync, и у вас, наконец, появится новая версия, которую можно тестировать. Этот этап показан на Рисунке 10.

Рис. 10: Нажмите кнопку Sync для синхронизации ваших изменений в текущей версии.

Теперь проведите несколько тестов production-маршрутов, используя ту же процедуру, которую вы использовали для циклов development и staging:

$ oc get routes -n knative-serving-ingress | grep production------------------------------------------------------------route-8c948175-70a8-4c1c-ae70-846aa3b2081f-643262313638   quarkus-hello-world-production.apps.ocp4.mydomain.com                    kourier    http2   edge/Allow    Noneroute-8c948175-70a8-4c1c-ae70-846aa3b2081f-663561353830   r9ce9024-quarkus-hello-world-production.apps.ocp4.mydomain.com           kourier    http2   edge/Allow    None$ curl http://quarkus-hello-world-production.apps.ocp4.mydomain.com/hellohola production! Yeap!$ curl http://r9ce9024-quarkus-hello-world-production.apps.ocp4.mydomain.com/hellohola production! Yeap!

Как показано на Рисунке 11, все приложения Argo CD сейчас синхронизированы.

Рис. 11: Все ваши объекты находятся на панели управления Argo CD.

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

Давайте теперь посмотрим, что происходит при развертывании новой версии нашего приложения quarkus-hello-world. В этом случае мы просто снова запускаем пайплайн CI/CD с другим ID коммита. Заметьте: пока что мы продолжаем запускать пайплайн вручную. Мы установим вебхуки для пайплайнов в последнем разделе статьи.
Перейдите в репозиторий rh-developers-cicd и запустите пайплайн, используя следующие параметры:

$ cat tekton/pipelines/knative-pipeline-run.yaml | \  SOURCE_REPO=https://github.com/dsanchor/quarkus-hello-world.git \  COMMIT=c076ee940b1f1d9576b7af3250bbbd7114e82263 \  SHORT_COMMIT=c076ee9 \  DEPLOYMENT_REPO=https://github.com/dsanchor/quarkus-hello-world-deployment.git \  IMAGES_NS=cicd envsubst | \  oc create -f - -n cicd------------------------------------------------------------------------------------pipelinerun.tekton.dev/knative-pipeline-run-j5knc created

Если вы предпочитаете запускать пайплайн через tkn CLI, выполните следующее:

$ tkn pipeline start knative-pipeline -p application=quarkus-hello-world \  -p source-repo-url=https://github.com/dsanchor/quarkus-hello-world.git \  -p source-revision=c076ee940b1f1d9576b7af3250bbbd7114e82263 \  -p short-source-revision=c076ee9 \  -p deployment-repo-url=https://github.com/dsanchor/quarkus-hello-world-deployment.git \  -p deployment-revision=master \  -p dockerfile=./src/main/docker/Dockerfile.jvm \  -p image-registry=image-registry.openshift-image-registry.svc.cluster.local:5000 \  -p image-repository=cicd \  -w name=source,claimName=source-pvc \  -w name=maven-settings,config=maven \  -w name=knative-kustomize-base,config=knative-kustomize-base \  -w name=knative-kustomize-environment,config=knative-kustomize-environment \  -n cicd

Примечание: Выполнение пайплайна может занять до пяти минут. В это время предлагаю вам прочитать статью об ускорении сборки Maven в Tekton.
Когда пайплайн закочит работу, новый образ (quarkus-hello-world:c076ee940b1f1d9576b7af3250bbbd7114e82263) будет отправлен во внутренний registry OpenShift в неймспейсе cicd. Также новые Kustomization-файлы будут отправлены в репозиторий quarkus-hello-world-deployment.

Логи выполнения

Проверка логов пайплайна позволяет нам увидеть изменения, которые отправляются в Git. В особенности обратите внимание на записи задачи push-knative-manifest:

add 'development/kustomization.yaml'remove 'development/r9ce9024/configmap.yaml'remove 'development/r9ce9024/revision-patch.yaml'remove 'development/r9ce9024/routing-patch.yaml'add 'development/rc076ee9/configmap.yaml'add 'development/rc076ee9/revision-patch.yaml'add 'development/rc076ee9/routing-patch.yaml'add 'production/kustomization-rc076ee9.yaml'add 'production/rc076ee9/configmap.yaml'add 'production/rc076ee9/revision-patch.yaml'add 'production/rc076ee9/routing-patch.yaml'add 'staging/kustomization-rc076ee9.yaml'add 'staging/rc076ee9/configmap.yaml'add 'staging/rc076ee9/revision-patch.yaml'add 'staging/rc076ee9/routing-patch.yaml'

Подведем итог:

• Новая версия доступна в development путем замены файла kustomization.yaml, который содержит ссылки на ресурсы новой версии. Заметьте, что в файле traffic-routing.yaml нет никаких изменений, так мы сохраняем все существующие правила маршрутов. (Например, мы можем сохранить все blue/green или canary правила маршрутов, сконфигурированные в предыдущей версии, если таковые были).
• Мы только добавляем новый маршрут для новой версии, и мы убираем все ссылки на предыдущие версии. В основном маршруте все еще может быть ссылка на предыдущую версию, в таком случае эта версия может быть временно доступна через основной маршрут. После того, как версия становится не маршрутизируемой, Knative по истечению заранее установленного промежутка времени очистит ее как мусор. Использование Knative уменьшает трудозатраты на эксплуатацию и обслуживание и делает нас чуточку счастливее.
• Мы также создаем необходимые файлы Kustomize для этой новой версии в средах staging и production, но на них еще нет ссылок в kustomization.yaml.

Вторая версия приложения в среде development

У нас есть новая версия сервиса Knative, но основной маршрут все еще ведет к предыдущему приложению, что показано на Рисунке 12.

Рис. 12: Основной маршрут указывает на предыдущую версию приложения.

Получите текущие маршруты для приложения, запущенного в среде development:

$ oc get routes -n knative-serving-ingress | grep development--------------------------------------------------------------route-e387d9ca-9f1b-4c15-9b83-7bea4d2d290c-313361326363   quarkus-hello-world-development.apps.ocp4.mydomain.com                   kourier    http2   edge/Allow    Noneroute-e387d9ca-9f1b-4c15-9b83-7bea4d2d290c-353136303164   rc076ee9-quarkus-hello-world-development.apps.ocp4.mydomain.com          kourier    http2   edge/Allow    None

Протестируйте оба, и вы заметите, что основной маршрут ведет к предыдущей версии:

$ curl http://quarkus-hello-world-development.apps.ocp4.mydomain.com/hellohola dev! Yeap!$ curl rc076ee9-quarkus-hello-world-development.apps.ocp4.mydomain.com/hellohola dev! Nice to see you back!

Если вы хотите направить часть трафика на новую версию по главному маршруту, просто измените traffic-routing.yaml. Зайдите в репозиторий quarkus-hello-world-deployment и выполните git pull. Затем переключитесь на папку development и отредактируйте файл traffic-routing.yaml.

Измените файл с этого:

- op: add  path: /spec/traffic  value:    - revisionName: quarkus-hello-world-r9ce9024      percent: 100

На этот:

- op: add  path: /spec/traffic  value:    - revisionName: quarkus-hello-world-r9ce9024      percent: 50    - revisionName: quarkus-hello-world-rc076ee9      percent: 50

И затем примените изменения:

$ git add development/traffic-routing.yaml && git commit -m "Splitted traffic between r9ce9024 %50 and rc076ee9 50" && \git push

Через две минуты Argo CD автоматически синхронизирует эти изменения, или вы можете запустить синхронизацию вручную, если хотите, чтобы изменения вступили в силу незамедлительно.

Если вы проверите основной маршрут, вы увидите, что он возвращает ответы от обеих версий:

$ watch -n1 curl http://quarkus-hello-world-production.apps.ocp4.mydomain.com/hello

Если вы хотите убедиться, что трафик не пойдет к какой-то старой версии приложения, просто уберите эту версию из файла traffic-routing.yaml. В итоге Knative ее очистит, что вы можете протестировать и самостоятельно.

Вторая версия приложения в среде staging

Мы еще не получили новую версию приложения в среде staging. Причина этого в том, что пайплайн CI еще не изменил файл kustomization.yaml. Вместо этого он только создал возможного кандидата:

kustomization-REVISION.yaml.

Давайте развернем эту новую версию (mv staging/kustomization-rc076ee9.yaml staging/kustomization.yaml). Мы пропишем тот же самый маршрут, что и в development, разделив трафик между двумя нашими текущими версиями:

$ git pull && \mv staging/kustomization-rc076ee9.yaml staging/kustomization.yaml && \cp development/traffic-routing.yaml staging/traffic-routing.yaml && \rm -rf staging/r9ce9024 && \git add  staging && git commit -m "Split traffic between r9ce9024 %50 and  rc076ee9 50%" && \git push

Заметьте, что мы также удалили папку более старой версии (rm -rf staging/r9ce9024). Пайплайн CI проделал это автоматически в development, но не в staging или production. Удаление предыдущей версии отличает development от двух других сред в демоверсии.
Окончательный результат приложения в staging будет таким же, как и в среде development, как показано на Рисунке 13.

Рис. 13: Приложения в development и staging синхронизированы.

Протестируем основной маршрут. Вы должны увидеть, что получаете ответы от обеих версий сервиса Knative:

$ watch -n1 curl http://quarkus-hello-world-staging.apps.ocp4.mydomain.com/hello

Вторая версия приложения в среде production

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

$ git pull && \mv production/kustomization-rc076ee9.yaml production/kustomization.yaml && \cp staging/traffic-routing.yaml production/traffic-routing.yaml && \rm -rf production/r9ce9024 && \git add production && git commit -m "Split traffic between r9ce9024 %50 and rc076ee9 50%" && \git push

OutOfSync

Посмотрев на панель управления Argo CD, как на Рисунке 14, вы должны увидеть, что статус приложения quarkus-hello-world-production OutOfSync. Затронутый объект объект сервиса Knative.

Рис. 14: Объект сервиса Knative не синхронизирован.

Кликните на поле OutOfSync под quarkus-hello-world и проверьте вкладку DIFF, как показано на Рисунке 15.

Рис. 15: Используйте инструмент Diff, чтобы найти различия между версиями приложения.

Интерфейс на Рис. 15 показывает различия между действующим и желаемым манифестом, действующая версия представлена слева. Различия именно те, которые мы и предполагали, поэтому давайте синхронизируем их вручную и развернем новую версию и правила маршрутизации в production.
Проведя синхронизацию, протестируйте основной маршрут:

$ watch -n1 curl http://quarkus-hello-world-production.apps.ocp4.mydomain.com/hello

Откат к предыдущему состоянию

До сих пор вы смотрели, как развертывать новые версии приложения в каждой среде. А что если вы обнаружите непредвиденное поведение в последней версии приложения в production? Давайте используем Argo CD для отката к предыдущему состоянию приложения.
С Argo CD мы можем сделать откат к любой версии кода или приложения в истории нашего репозитория Git. Например, сделаем откат к предыдущей версии. Щелкните на History and Rollback на панели управления Argo CD, как показано на Рисунке 16.

Рис. 16: Использование функции History and Rollback, чтобы вернуться к предыдущей версии приложения.

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

Рис. 17: Выберите нужную версию и нажмите Rollback.

Как показано на Рисунке 17, в результате приложение имеет текущий статус OutOfSync, но оно синхронизировано с версией, которую мы выбрали для отката. Проверьте, что откат сработал, проведя следующие тесты:

$ watch -n1 curl http://quarkus-hello-world-production.apps.ocp4.mydomain.com/hello

Вы сможете убедиться, что ответы приходят от предыдущей версии приложения, а не от последней.

Примечание: Если у вас была активирована опция автосинхронизации для среды production, вам надо ее отключить перед проведением отката. Иначе все снова автоматически синхронизируется с последней версией.

Замыкаем круг: полностью автоматизированный CI/CD

До сих пор мы запускали пайплайн только вручную. Финальным этапом в нашем процессе мы настроим автоматизацию запуска пайплайна.

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

Перед началом сделайте форк репозитория исходного кода по адресу: https://github.com/dsanchor/quarkus-hello-world.git. Мы используем его для финального примера.

Добавление триггера Tekton

На стороне Tekton мы создадим три различных типа объектов, которые работают сообща:

• TriggerTemplate
• TriggerBinding
• EventListener

В EventListener мы добавим два перехватчика:

• Перехватчик GitHub добавляет простую проверку, основанную на общем токене.
• Перехватчик CEL применяет базовую функцию для сокращения ID коммита, чтобы он стал доступен для пайплайна.

Первым шагом создайте secret со случайным токеном:

$ oc create secret generic webhook --from-literal=token=XXXXXXXXXXXXXX -n cicd

Затем создайте общие для разных приложений TriggerTemplate и TriggerBinding:

$ oc apply -f tekton/webhook/knative-pipeline-trigger.yaml -n cicd--------------------------------------------------------------------triggerbinding.triggers.tekton.dev/webhook-body-binding createdtriggertemplate.triggers.tekton.dev/knative-pipeline-template created

После этого создайте специфические для каждого приложения EventListener и TriggerBinding. Важно: используйте собственный репозиторий развертывания в DEPLOYMENT_REPO_URL:

$ cat tekton/webhook/app-custom-trigger.yaml | \  GITHUB_SECRET=webhook \  APPLICATION=quarkus-hello-world \  NS=cicd \  DEPLOYMENT_REPO_URL=https://github.com/dsanchor/quarkus-hello-world-deployment \  DEPLOYMENT_REPO_REVISION=master \  envsubst | oc apply -f - -n cicd-------------------------------------------------------------------------------------eventlistener.triggers.tekton.dev/quarkus-hello-world-listener createdtriggerbinding.triggers.tekton.dev/quarkus-hello-world-binding created

Сделайте expose для сервиса event-listener, который будет целевым эндпоинтом вашего вебхука в GitHub:

$ oc expose svc el-quarkus-hello-world-listener -n cicd

И получите маршрут:

$ oc get route el-quarkus-hello-world-listener -n cicd--------------------------------------------------------NAME                              HOST/PORT                                                               PATH   SERVICES                          PORT            TERMINATION   WILDCARDel-quarkus-hello-world-listener   el-quarkus-hello-world-listener-cicd.apps.ocp4.mydomain.com          el-quarkus-hello-world-listener   http-listener                 None

Настройка вебхука в GitHub

Теперь перейдите в репозиторий вашего приложения на GitHub. В пункте меню Settings выберите Webhooks -> Add Webhooks, как показано на Рисунке 18.

Рис. 18: Добавление вебхука в вашего приложения на GitHub проекта.

Добавьте маршрут в качестве URL-адреса полезной нагрузки, установите тип контента как JSON и, наконец, скопируйте содержание токена в раздел secret, как показано на Рисунке 19.

Рис. 19: Конфигурация вебхука.

Как только вы добавили эти финальные элементы, вы должны увидеть на экране единственный вебхук.

Проверим, что получилось

Я внесу простое изменение в класс GreetingResource. Вам нужно внести те же самые изменения в ваш Greeting Resource Test. В моем случае я меняю последнюю часть сообщения на Webhooks work.

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

$ git add src  && \git commit -m "Changed greeting message" && \git push

Пайплайн уже должен был запуститься. Если вы столкнетесь с ошибкой, вам стоит проверить event listener под в кластере, который мы создали для управления событиями для EventListener. Чтобы получить имя пода, выполните:

$ oc get pod -l eventlistener=quarkus-hello-world-listener -n cicd

Дождитесь завершения работы пайплайна. После этого у вас должна появиться новая версия сервиса Knative в окружении development. Вы можете использовать новинку: developer perspective в веб-консоли OpenShift для того, чтобы убедиться, что сервис Knative работает. Выберите проект development и проверьте его топологию, как показано на Рисунке 20.

Рис. 20: Используйте developer perspective OpenShift для того, чтобы убедиться в работе сервиса Knative.

Вы должны увидеть три работающие версии (хотя все они свёрнуты до минимума из-за неактивности). Две версии, которые мы с вами развернули за первые этапы этой статьи, лежат на основном маршруте, каждая из них берет на себя половину трафика. Последняя версия имеет свой маршрут, созданный нашим пайплайном. Давайте отправим на него запрос и посмотрим на результаты:

$ curl r1b644f0-quarkus-hello-world-development.apps.ocp4.mydomain.com/hellohola dev! Webhooks work!

Knative автоматически смасштабировал эту версию до одного пода, что показано на Рисунке 21.

Рис. 21: Knative провел автоматическое масштабирование последней версии приложения.

Заключение

Вторая часть статьи, посвященной введению в построение современных процессов CI/CD, познакомила вас с использованием Argo CD для реализации непрерывной доставки в бессерверном процессе CI/CD. Совмещение Tekton и GitOps при помощи Argo CD, становится все более популярным решением для полностью автоматического CI/CD.

Начни новое:

• Multipath TCP в Red Hat Enterprise Linux 8.3: как включить и начать использовать
  В грядущей RHEL 8.3 функционал Multipath TCP появится в версии Tech Preview, однако попрактиковаться в настройке клиентов и серверов можно уже сегодня.
• OpenShift присоединяется к сообществу Argo CD (KubeCon Europe 2020)
  Argo CD это опенсорсный GitOps-оператор для декларативной настройки кластеров Kubernetes, и теперь он есть в Red Hat OpenShift.
• OpenShift 4.5: Kubernetes 1.18 и многое другое
  Обзор новых операционных и девелоперские функций OpenShift 4.5, появившихся вместе с Kubernetes 1.18.
• iptables: старый и новый варианты, и как они связаны с более новой утилитой nftables
  Рассмотрим связь между iptables и nftables и покажем, как iptables-nft объединяет лучшие стороны этих двух инструментов, чтобы не трогать унаследованный код.
• Учимся создавать Kubernetes-операторы
  Создание, тестирование и экспорт Kubernetes Operatorа с кастомным namespace-scope с помощью языка Golang и Kubernetes Operator SDK.
• Red Hat CodeReady Workspaces 2.3: улучшенное конфигурирование и кое-что еще
• Kubernetes-нативный Apache Kafka в проектах Strimzi, Debezium Apache Camel (Kafka Summit 2020)
• 10 Kubernetes-инструментов из разряда важно (видеоурок DevNation Tech Talk, 36 минут)
• Kubernetes-операторы

Качай (это легально):

• Бесплатная электронная книга Kubernetes Patterns: повторно используемые элементы при конструировании облачно-ориентированных приложений (осторожно, требуется регистрация; без регистрации качай с Google Docs)
  Напишите сюда, если ни один вариант не устроил: evelina@redhat.com
  
  
  
  
  
• Шпаргалка по созданию Kubernetes-операторов на Java (осторожно, требуется регистрация; без регистрации качай с Google Docs)
  Напишите сюда, если ни один вариант не устроил: evelina@redhat.com
  
  
  
  
  

Почитать на досуге:

• Создаем и запускаем Python-приложения прямо на Android-смартфоне
• Red Hat: Виртуальные машины больше не являются гражданами второго сорта на платформе OpenShift

Мероприятия:

• Смотрите прошлые и будущие выпуски ток-шоу DevNation на YouTube
• 1 сентября, ток-шоу DevNation
  Часовая беседа с Sebastian Daschner, ведущим Java Developer Advocate в IBM. Также в программе: новости с Kafka Summit и из мира Java, плюс интерактивная игра, чтобы не скучать.
• 3 сентября, DevNation Tech Talk Облачная модернизация или смерть почему это ложная дилемма
  Расскажем, как мигрировать монолитные приложения на современную контейнерную платформу Kubernetes/OpenShift, и затем осовременить их с помощью микросервисов и облачных runtime-компонентов Spring Boot и Quarkus от Red Hat.
• 15 сентября, DevNation Day 2020
  Бесплатная виртуальная конференция по вопросам разработки и технологий с участием экспертов Red Hat Developer и представителей других ИТ-компаний и отраслей.
• 13-14 октября, AnsibleFest
  Выступления, демонстрации, практические занятия и все это в онлайне. Отличная возможность виртуально пообщаться с девелоперами, админами и ЛПР-ами, которые успешно справляются с вызовами перемен, используя опенсорсные технологии ИТ-автоматизации.

По-русски:

• 11 сентября
  OpenShift-специфичные волшебные вещи для сборки и развертывания приложений
• 25 сентября
  Red Hat OpenShift и Machine API
• 9 октября
  Как справиться с внезапным ростом нагрузки
• 23 октября
  Встроенный Jenkins, Pipeline-builds, Tekton в Red Hat OpenShift Container Platform

Начни новое:

• Опенсорсная виртуализация: Linux на Macе
  Как запустить Fedora под macOS с помощью виртуальной машины QEMU.
• Практический учебник по awk
  Бесплатная электронная книга по скриптовому языку awk.
• Ваяем консоль удаленного управления на Python и Jupyter Notebooks
  Как превратить Jupyter в консоль удаленного администрирования.
  
  
  
  
  
• Создаем обложку книги в опенсорсном аналоге Adobe InDesign
• 4 причины использовать Jamstack при веб-разработке
• Как правильно открывать порты и маршрутизировать трафик через брандмауэр
• OpenShift Pipelines и Argo CD: путь от кода в продакшн:
  Как использовать Argo CD, Tekton и OpenShift Pipelines для управления рабочими процессами CI/CD в тестовой и продакшн-средах.
• Eclipse JKube 1.0.0 разрабатывать Java-приложения для облака стало проще
  Eclipse JKube 1.0.0 это наследник проекта Fabric8 Maven Plugin, и он предлагает много нового для сборки Java-контейнеров Maven, например, поддержку стратегий сборки S2I.
• Ставим Red Hat OpenShift Operators на ноутбук с помощью Red Hat CodeReady Containers и Red Hat Marketplace
  Учимся устанавливать контейнеризованные продукты из магазина приложений Red Hat Marketplace в локальный девелоперский OpenShift-кластер CodeReady.
• Quarkus и Jakarta EE: таки вместе или нет?
  Будет ли Quarkus совместим с Jakarta EE? Простым да или нет тут не обойдешься, так что разбираем в деталях.
• 5 советов по разработке Kubernetes Operators с помощью нового Operator SDK
  Секреты-советы по разработке Kubernetes Operators с использованием Operator SDK 1.0 и Helm, Ansible или Go (даже если вы не пишите на Go), включая массу примеров.
• Как держать в секрете Kubernetes-секреты (видеоурок DevNation Tech Talk, 35 минут)

Качай:

• Шпаргалка по Ansible k8s
  Ansible k8s это специальный модуль для управления объектами Kubernetes из плейбуков Ansible. Как объединить Ansible и Kubernetes при автоматизации облака? Ответ: использовать модуль Ansible k8s, чтобы управлять объектами Kubernetes прямо из плейбуков. И поможет в этом наша шпаргалка, которая содержит полезные советы и сведения по ключевым командам этого модуля.
• Шпаргалка по тестированию приложений Quarkus
  
  
  
  
  
• Книжка-раскраска Контейнерные супергерои
  Децентрализованная команда опенсорсных контейнерных супергероев в лице Podman, CRI-O, Buildah, Skopeo и OpenShift спасает Землю от атаки астероидов, развертывая над планетой защитный экран.
  
  
  
  
  

Почитать на досуге:

• Девелоперские инструменты в магазине приложений Red Hat Marketplace
• Введение в корпоративный Kubernetes
• Бесплатный онлайн-курс Технический обзор RHEL
• Kubernetes-операторы: как сделать эксплуатационный регламент частью контейнеризованных приложений
• Как успешно пройти первые 90 дней на новой работе в режиме удаленки

Мероприятия:

• 30 сентября, jconf.dev
  Бесплатная виртуальная Java-конференция прямо у вас на экране. Четыре технотрека с экспертами по Java и облаку, 28 углубленных сессий и два потрясающих основных доклада.
• 13-14 октября, AnsibleFest
  Выступления, демонстрации, практические занятия и все это в онлайне. Отличная возможность виртуально пообщаться с девелоперами, админами и ЛПР-ами, которые успешно справляются с вызовами перемен с помощью опенсорсных технологий ИТ-автоматизации.

По-русски:

• 25 сентября
  Red Hat OpenShift и Machine API
• 9 октября
  Как справиться с внезапным ростом нагрузки
• 23 октября
  Встроенный Jenkins, Pipeline-builds, Tekton в Red Hat OpenShift Container Platform

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

При развертывании в кластере Kubernetes Tekton Pipelines предоставляет возможность определять и выполнять задачи сборки, входные и выходные данные в форме простых значений или сложных объектов, таких как образы Docker, и объединять эти ресурсы в конвейеры. Эти новые ресурсы Kubernetes и контроллеры, которые ими управляют, приводят к созданию автономной платформы CI / CD, размещенной в кластере Kubernetes.

В этом посте мы рассмотрим простой конвейер сборки, работающий на MicroK8S.

Подготовка тестового кластера Kubernetes

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

microk8s.enable registry

Нам также необходимо включить поиск DNS из кластера MicroK8S. Это делается путем включения надстройки DNS:

microk8s.enable dns

Установка Tekton Pipelines

Установка Tekton Pipelines выполняется с помощью одной команды kubectl (или microk8s.kubectl в нашем случае):

microk8s.kubectl apply --filename https://storage.googleapis.com/tekton-releases/pipeline/latest/release.yaml

Теперь мы можем создавать ресурсы Tekton в нашем кластере Kubernetes.

Задача "Hello World"

Задачи содержат отдельные шаги, которые выполняются для выполнения работы. В приведенном ниже примере у нас есть задача с одним шагом, которая выполняет команду echo с аргументами Hello World в контейнере, созданном из образа ubuntu.

В YAML ниже показан наш файл helloworldtask.yml:

apiVersion: tekton.dev/v1alpha1kind: Taskmetadata:  name: echo-hello-worldspec:  steps:    - name: echo      image: ubuntu      command:        - echo      args:        - "Hello World"

Ресурс задачи создается в кластере Kubernetes командой:

microk8s.kubectl apply -f helloworldtask.yml

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

В YAML ниже показан наш файл helloworldtaskrun.yml:

apiVersion: tekton.dev/v1alpha1kind: TaskRunmetadata:  name: echo-hello-world-task-runspec:  taskRef:    name: echo-hello-world

Ресурс запуска задачи создается в кластере Kubernetes с помощью команды:

microk8s.kubectl apply -f helloworldtaskrun.yml

Создание образа Docker

Чтобы выйти за рамки этого примера hello world, мы рассмотрим канонический вариант использования конвейера сборки Tekton, который заключается в компиляции и отправке образа Docker. Чтобы продемонстрировать эту функциональность, мы создадим наше примерное приложение RandomQuotes.

Мы запускаем конвейер с конвейерного ресурса. Ресурсы конвейера обеспечивают независимый метод определения входных данных для процесса сборки.

Первый вход, который нам нужен, это репозиторий Git, в котором хранится наш код. Ресурсы конвейера имеют несколько известных типов, и здесь мы определяем ресурс конвейера git, указывающий URL-адрес и ветвь, содержащую наш код:

apiVersion: tekton.dev/v1alpha1kind: PipelineResourcemetadata:  name: randomquotes-gitspec:  type: git  params:    - name: revision      value: master    - name: url      value: https://github.com/OctopusSamples/RandomQuotes-Java.git

Затем мы определяем реестр Docker, содержащий наш скомпилированный образ. В этом случае полезна надстройка реестра MicroK8S, поскольку она предоставляет доступ к реестру Docker по адресу http://registry.container-registry.svc.cluster.local:5000.

Вот конвейерный ресурс типа image, определяющий образ Docker, который мы создадим как registry.container-registry.svc.cluster.local:5000/randomquotes:

apiVersion: tekton.dev/v1alpha1kind: PipelineResourcemetadata:  name: randomquotes-imagespec:  type: image  params:    - name: url      value: registry.container-registry.svc.cluster.local:5000/randomquotes

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

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

За последние несколько лет появилось множество инструментов, предназначенных для выполнения процессов, предоставляемых Docker CLI и демоном, но без какой-либо зависимости от самого Docker. К ним относятся такие инструменты, как umoci для распаковки и переупаковки образов Docker, Kaniko и Buildah для создания образов Docker из файла Docker и Podman для запуска образов Docker.

Мы будем использовать Kaniko в нашей задаче Tekton, чтобы создать образ Docker внутри контейнера Docker, предоставленного Kubernetes. YAML ниже показывает полную задачу:

apiVersion: tekton.dev/v1alpha1kind: Taskmetadata:  name: build-docker-image-from-git-sourcespec:  inputs:    resources:      - name: docker-source        type: git    params:      - name: pathToDockerFile        type: string        description: The path to the dockerfile to build        default: /workspace/docker-source/Dockerfile      - name: pathToContext        type: string        description:          The build context used by Kaniko          (http://personeltest.ru/aways/github.com/GoogleContainerTools/kaniko#kaniko-build-contexts)        default: /workspace/docker-source  outputs:    resources:      - name: builtImage        type: image  steps:    - name: build-and-push      image: gcr.io/kaniko-project/executor:v0.17.1      # specifying DOCKER_CONFIG is required to allow kaniko to detect docker credential      env:        - name: "DOCKER_CONFIG"          value: "/tekton/home/.docker/"      command:        - /kaniko/executor      args:        - --dockerfile=$(inputs.params.pathToDockerFile)        - --destination=$(outputs.resources.builtImage.url)        - --context=$(inputs.params.pathToContext)

Стоит отметить несколько важных аспектов этой задачи.

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

Входной ресурс типа git:

inputs:    resources:      - name: docker-source        type: git

И вывод типа image:

outputs:  resources:    - name: builtImage      type: image

Есть два дополнительных входных параметра, которые определяют пути, используемые для процесса сборки Docker:

spec:  inputs:    params:      - name: pathToDockerFile        type: string        description: The path to the dockerfile to build        default: /workspace/docker-source/Dockerfile      - name: pathToContext        type: string        description:          The build context used by Kaniko          (http://personeltest.ru/aways/github.com/GoogleContainerTools/kaniko#kaniko-build-contexts)        default: /workspace/docker-source

Обратите внимание, что путь /workspace/docker-source это соглашение, используемое ресурсами git, с каталогом docker-source, совпадающим с именем ввода.

Затем у нас есть один шаг, который создает образ Docker. Сборка выполняется в контейнере, созданном из образа gcr.io/kaniko-project/executor:v0.17.1 image, который предоставляет Kaniko:

spec:  steps:    - name: build-and-push      image: gcr.io/kaniko-project/executor:v0.17.1      # specifying DOCKER_CONFIG is required to allow kaniko to detect docker credential      env:        - name: "DOCKER_CONFIG"          value: "/tekton/home/.docker/"      command:        - /kaniko/executor      args:        - --dockerfile=$(inputs.params.pathToDockerFile)        - --destination=$(outputs.resources.builtImage.url)        - --context=$(inputs.params.pathToContext)

И наконец, запуск задачи используется для связывания ресурсов задачи и конвейера. Этот ресурс сопоставляет входные данные docker-source задачи с ресурсом конвейера randomquotes-git, а выходные данные builtImage с ресурсом конвейера randomquotes-image.

После создания этого ресурса запускается сборка:

apiVersion: tekton.dev/v1alpha1kind: TaskRunmetadata:  name: build-docker-image-from-git-source-task-runspec:  taskRef:    name: build-docker-image-from-git-source  inputs:    resources:      - name: docker-source        resourceRef:          name: randomquotes-git    params:      - name: pathToDockerFile        value: Dockerfile      - name: pathToContext        value: /workspace/docker-source  outputs:    resources:      - name: builtImage        resourceRef:          name: randomquotes-image

Взаимодействие со сборками

Сам Tekton не предоставляет никаких панелей управления или графического интерфейса для взаимодействия с заданиями. Однако есть инструмент командной строки для управления заданиями Tekton.

Инструмент Tekton CLI предполагает, что kubectl настроен, но MicroK8S поддерживает отдельный инструмент под названием microk8s.kubectl. Самый простой способ настроить kubectl использовать следующую команду, которая копирует файл конфигурации MicroK8S в стандартное расположение для kubectl:

sudo microk8s.kubectl config view --raw > $HOME/.kube/config

На этом этапе мы можем получить статус задачи с помощью команды:

tkn taskrun logs build-docker-image-from-git-source-task-run

Подходит ли вам Tekton?

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

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

Однако я подозреваю, что Tekton не находится на том уровне, необходимом для большинства инженерных команд. Инструмент tkn CLI будет знаком любому, кто раньше использовал kubectl, но сложно понять общее состояние ваших сборок из терминала. Не говоря уже о создании сборок с помощью kubectl create -f taskrun.yml, которые быстро устаревают.

Доступна информационная панель, но это простой пользовательский интерфейс по сравнению с существующими инструментами CI.

Тем не менее, Tekton это мощная основа для создания инструментов для разработчиков. Jenkins X и OpenShift Pipelines две такие платформы, которые используют Tekton.

Вывод

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

С такими проектами, как Jenkins X и OpenShift Pipelines, Tekton находится в начале пути к основным рабочим процессам разработки. Но как отдельный проект Tekton находится на низком уровне своих возможностей, чтобы его могло использовать большинство команд разработчиков, хотя бы потому, что у немногих людей будет опыт, чтобы поддержать его.

В этой статье мы собираемся создать пайплайн непрерывной интеграции (CI) с Tekton, фреймворком с открытым исходным кодом для создания конвейеров CI / CD в Kubernetes.

Мы собираемся подготовить локальный кластер Kubernetes через kind и установить на нем Tekton. После этого мы создадим пайплайн, состоящий из двух шагов, который будет запускать модульные тесты приложения, создавать образ Docker и отправлять его в DockerHub.

Это 1 из 2 частей, в которой мы установим Tekton и создадим задачу, запускающую тест нашего приложения. Вторая часть доступна здесь.

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

Мы используем kind для создания кластера Kubernetes для нашей установки Tekton:

$ kind create cluster --name tekton

Установка Tekton

Мы можем установить Tekton, применив файл release.yaml из последней версии репозитория tektoncd/pipeline на GitHub:

$ kubectl apply -f https://storage.googleapis.com/tekton-releases/pipeline/previous/v0.20.1/release.yaml

Это установит Tekton в пространство имен tekton-pipelines. Мы можем проверить успешность установки, указав модули в этом пространстве имен и убедившись, что они находятся в состоянии выполнения.

$ kubectl get pods --namespace tekton-pipelinesNAME                                           READY   STATUS    RESTARTS   AGEtekton-pipelines-controller-74848c44df-m42gf   1/1     Running   0          20stekton-pipelines-webhook-6f764dc8bf-zq44s      1/1     Running   0          19s

Настройка Tekton CLI

Установка интерфейса командной строки не является обязательной, но я считаю, что это удобнее, чем kubectl, при управлении ресурсами Tekton. Примеры, приведенные ниже, покажут оба пути.

Мы можем установить его через Homebrew:

$ brew tap tektoncd/tools$ brew install tektoncd/tools/tektoncd-cli$ tkn versionClient version: 0.16.0Pipeline version: v0.20.1

Концепции

Tekton предоставляет пользовательские определения ресурсов (CRD) для Kubernetes, которые можно использовать для определения наших пайплайнов. В этом руководстве мы будем использовать следующие настраиваемые ресурсы:

• Задача: серия шагов, которые выполняют команды (в CircleCI это называется Job).

  
  

• Пайплайн: набор задач (в CircleCI это называется рабочим процессом Workflow)

  
  

• PipelineResource: ввод или вывод Pipeline (например, репозиторий git или файл tar)

  
  

Мы будем использовать следующие два ресурса для определения выполнения наших задач и пайплайна:

• TaskRun: определяет выполнение задачи
• PipelineRun: определяет выполнение пайплайна

Например, если мы пишем задачу и хотим ее протестировать, мы можем выполнить ее с помощью TaskRun. То же самое относится и к пайплайну: для выполнения конвейера нам нужно создать PipelineRun.

Код приложения

В нашем примере Pipeline мы собираемся использовать приложение Go, которое просто выводит сумму двух целых чисел. Вы можете найти код приложения, тест и Dockerfile в каталоге src/ этого репо.

Создание нашей первой задачи

Наша первая задача будет запускать тесты приложения внутри клонированного репозитория git. Создайте файл 01-task-test.yaml со следующим содержимым:

apiVersion: tekton.dev/v1beta1kind: Taskmetadata:  name: testspec:  resources:    inputs:      - name: repo        type: git  steps:    - name: run-test      image: golang:1.14-alpine      workingDir: /workspace/repo/src      command: ["go"]      args: ["test"]

Блок resources: определяет входные данные, необходимые нашей задаче для выполнения своих шагов. Нашему шагу (названному run-test) требуется клонированный репозиторий git с примером tekton в качестве входных данных, и мы можем создать эти входные данные с помощью PipelineResource.

Создайте файл с названием 02-pipelineresource.yaml:

apiVersion: tekton.dev/v1alpha1kind: PipelineResourcemetadata:  name: arthurk-tekton-examplespec:  type: git  params:    - name: url      value: https://github.com/arthurk/tekton-example    - name: revision      value: master

Тип ресурса git будет использовать git для клонирования репозитория в каталог /workspace/$input_name при каждом запуске задачи. Поскольку наш ввод называется repo, код будет клонирован в /workspace/repo. Если бы наш ввод был назван foobar, он был бы клонирован в /workspace/foobar.

Следующий блок в нашей задаче (steps:) определяет команду для выполнения и образ Docker, в котором следует выполнить эту команду. Мы собираемся использовать образ golang Docker, так как Go уже установлен.

Для запуска команды go test нам нужно сменить каталог. По умолчанию команда запускается в каталоге /workspace/repo, но в нашем репозитории с примером tekton приложение Go находится в каталоге src. Мы делаем это, установив рабочий каталог: /workspace/repo/src.

Затем мы указываем команду для запуска (go test), но обратите внимание, что команда (go) и args (test) должны быть определены отдельно в файле YAML.

Примените Task и PipelineResource с помощью kubectl:

$ kubectl apply -f 01-task-test.yamltask.tekton.dev/test created$ kubectl apply -f 02-pipelineresource.yamlpipelineresource.tekton.dev/arthurk-tekton-example created

Выполняем нашу задачу

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

Создайте файл 03-taskrun.yaml со следующим содержимым:

apiVersion: tekton.dev/v1beta1kind: TaskRunmetadata:  name: testrunspec:  taskRef:    name: test  resources:    inputs:      - name: repo        resourceRef:          name: arthurk-tekton-example

Это примет нашу задачу (taskRef это ссылка на нашу ранее созданную задачу с именем test) с нашим репозиторием git tekton-example в качестве входных данных (resourceRef это ссылка на наш PipelineResource с именем arthurk-tekton-example) и выполнит ее.

Примените файл с помощью kubectl, а затем проверьте ресурсы Pods и TaskRun. Pod пройдет через статус Init:0/2 и PodInitializing, а затем успешно:

$ kubectl apply -f 03-taskrun.yamlpipelineresource.tekton.dev/arthurk-tekton-example created$ kubectl get podsNAME                READY   STATUS      RESTARTS   AGEtestrun-pod-pds5z   0/2     Completed   0          4m27s$ kubectl get taskrunNAME      SUCCEEDED   REASON      STARTTIME   COMPLETIONTIMEtestrun   True        Succeeded   70s         57s

Чтобы увидеть вывод контейнеров, мы можем запустить следующую команду. Обязательно замените testrun-pod-pds5z на имя модуля из выходных данных выше (оно будет отличаться для каждого запуска).

$ kubectl logs testrun-pod-pds5z --all-containers{"level":"info","ts":1588477119.3692405,"caller":"git/git.go:136","msg":"Successfully cloned https://github.com/arthurk/tekton-example @ 301aeaa8f7fa6ec01218ba6c5ddf9095b24d5d98 (grafted, HEAD, origin/master) in path /workspace/repo"}{"level":"info","ts":1588477119.4230678,"caller":"git/git.go:177","msg":"Successfully initialized and updated submodules in path /workspace/repo"}PASSok      _/workspace/repo/src    0.003s

Наши тесты прошли, и наша задача была выполнена. Затем мы воспользуемся Tekton CLI, чтобы увидеть, как мы можем упростить весь этот процесс.

Использование Tekton CLI для запуска задачи

Tekton CLI обеспечивает более быстрый и удобный способ запуска задач.

Вместо того, чтобы вручную писать манифест TaskRun, мы можем запустить следующую команду, которая берет нашу задачу (с именем test), генерирует TaskRun (со случайным именем) и отображает ее журналы:

$ tkn task start test --inputresource repo=arthurk-tekton-example --showlogTaskrun started: test-run-8t46mWaiting for logs to be available...[git-source-arthurk-tekton-example-dqjfb] {"level":"info","ts":1588477372.740875,"caller":"git/git.go:136","msg":"Successfully cloned https://github.com/arthurk/tekton-example @ 301aeaa8f7fa6ec01218ba6c5ddf9095b24d5d98 (grafted, HEAD, origin/master) in path /workspace/repo"}[git-source-arthurk-tekton-example-dqjfb] {"level":"info","ts":1588477372.7954974,"caller":"git/git.go:177","msg":"Successfully initialized and updated submodules in path /workspace/repo"}[run-test] PASS[run-test] ok   _/workspace/repo/src    0.006s

Вывод

Мы успешно установили Tekton в локальном кластере Kubernetes, определили задачу и протестировали ее, создав TaskRun через манифест YAML, а также через Tekton CLI tkn.

Весь пример кода доступен здесь.

В следующей части мы собираемся создать задачу, которая будет использовать Kaniko для создания образа Docker для нашего приложения, а затем будет отправлять его в DockerHub. Затем мы создадим пайплайн, который последовательно будет запускать обе наши задачи (запускать тесты приложения, сборку и отправку).

Часть 2 доступна здесь.