Глава 4. Введение в функционирование Kubeless

В Kubeless имеются два компонента; первым из них является собственно стек, который исполняется в Kubernetes, а второй частью является клиент командной строки, который вы применяете в своём кластере Kubeless.

Вначале мы взглянем на получение поднятой и работающей необходимой стороны Kubernetes в Kubeless. После её поднятия мы затем рассмотрим установку клиента команд в своих трёх целевых операционных системах.

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

$ minikube delete
$ minikube start
		

Теперь, когда у нас имеется поднятым и исполняемым очищенный кластер Kubernetes из одного узла, нам требуется создать некое пространство имён для Kubeless, выполнив:

$ kubectl create ns kubeless
		

А затем установить собственно Kubeless, исполнив следующую команду:

$ kubectl create -f https://github.com/kubeless/kubeless/releases/download/v0.2.3/kubeless-v0.2.3.yaml
		

Как вы можете видеть, эта команда создаст и запустит все необходимые компоненты для исполнения Kubeless в вашем кластере Kubernetes из одного узла:

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

$ kubectl get pods -n kubeless
$ kubectl get deployment -n kubeless
$ kubectl get statefulset -n kubeless
		

Вы должны увидеть что- то подобное такому выводу:

Как альтернатива, вы можете проверить при помощи инструментальной панели Kubernetes. Для этого откройте свою инструментальную панель, выполнив:

$ minikube dashboard
		

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

Когда вы измените пространства имён, вы должны увидить несто подобное следующей странице:

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

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

Поскольку у нас уже имеется установленным Homebrew из предыдущей главы, для установки Kubeless мы собираемся воспользоваться командой brew. Для этого нам необходимо добавить Kubeless tap; tap является сторонним репозиторием, который содержит инструкции установки программного обеспечения. После добавления tap мы можем установить Kubeless во многом похожим образом на то, как мы устанавливали Minikube в Главе 2, Введение в Kubernetes.

Чтобы установить tap, а затем установить необходимого клиента Kubeless, исполните две следующие команды:

$ brew tap kubeless/tap
$ brew install kubeless
		

После установки вы можете проверить текущую версию установленного клиента, выполнив такую команду:

$ kubeless version
		

К сожалению, нет установщика Chocolatey для Kubeless, поэтому нам придётся выгрузить и раскрыть необходимый исполняемый файл вручную. Чтобы сделать это в PowerShell выполните следующие команды:

$ Invoke-WebRequest -Uri https://github.com/kubeless/kubeless/releases/download/v0.2.3/kubeless_windows-amd64.zip -Outfile C:\Temp\kubeless_windows-amd64.zip
$ expand-archive -path 'C:\Temp\kubeless_windows-amd64.zip' -destinationpath 'C:\Temp\kubeless_windows-amd64'
$ Move-Item C:\Temp\kubeless_windows-amd64\bundles\kubeless_windows-amd64\kubeless.exe .\
		

В противоположность этому вы можете выгрузить необходимый файл kubeless_windows-amd64.zip прямо со страницы выпусков Kubeless. После выгрузки раскройте полученный файл .zip и поместите полученный файл kubeless.exe туда, где мы можем его исполнять. Из папки, которая содержит этот файл kubeless.exe выполните следующую команду:

$ ./kubeless version
		

Она возвратит вам текущую версию вашего клиента командной строки.

Как и с версией Windows 10 клиента командной строки для Kubeless мы должны выгрузить необходимый выпуск, раскройте его, и переместите исполняемый файл в необходимое место. Для этого выполните следующие команды:

$ curl -Lo /tmp/kubeless.zip https://github.com/kubeless/kubeless/releases/download/v0.2.3/kubeless_linux-amd64.zip
$ unzip /tmp/kubeless.zip -d /tmp
$ chmod +x /tmp/bundles/kubeless_linux-amd64/kubeless
$ sudo mv /tmp/bundles/kubeless_linux-amd64/kubeless /usr/local/bin/
		

Наконец, проверьте что исполняемый файл работает как следует, исполните:

$ kubeless version
		

Мы готовы использовать Kubeless в своём хосте Ubuntu Linux.

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

$ kubectl create -f https://raw.githubusercontent.com/kubeless/kubeless-ui/master/k8s.yaml
		

Затем вы можете применить Minikube чтобы открыть соответствующую службу в своём браузере:

$ minikube service ui --namespace kubeless
		

Как вы можете видеть из предыдущей команды, так как служба ui была развёрнута в нашем пространстве имён kubeless, нам необходимо позволить Minikube знать что именно здесь доступна данная служба передав ему флаг --namespace. На запуск веб интерфейса Kubeless может понадобиться несколько минут, однако когда он состоится, вас должна поприветствовать страница, которая выглядит как- то так:

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

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

Kubeless является инфраструктурой, которая поддерживает развёртывание функций без сервера в вашем кластере и он даёт нам возможность исполнения как HTTP так и переключателей событий в вашем коде Python, Node.js или Ruby. Эта инфраструктура построена с применением функциональности ядра Kubernetes, такой как развёртывание, службы, карты настройки (ConfigMaps) и тому подобное. Это сохраняет базовый код Kubeless с малым размером, а также означает что разработчики не должны повторно воспроизводить большие порции кода логики ведения расписаний, которые уже имеются внутри самого ядра Kubernetes.

Он работает путём получения преимуществ контроллера Kubernetes. Применяя контроллеры, разработчики Kubeless расширили API Kubernetes добавлением объекта функции внутри Kubernetes. Сам контроллер Kubeless исполняется внутри нашего кластера Kubernetes как оснащение, его первичным заданием является отслеживание подлежащих вызовам функциям конечных точек. Когда такая контрольная точка вызывается, работает код времени исполнения, содержащий необходимый код функции; это предварительно построенные образы Docker, которые обёртывают ваши функции, которые инъектируются с применением ConfigMaps либо как потребитель Apache Kafka, который используется для событий, или как некий сервер HTTP, который вы можете вызывать как и любую другую веб страницу в вашем кластере Kubernetes.

Всё это означает, что мы можем получить практику применения, аналогичную тем службам без сервера, которые мы описывали касательно AWS и Microsoft Azure в Главе 1, Ландшафт без серверов, в своём кластере Kubernetes,и в том числе в исполняемом нами локально кластере одного узла.

Kubeless был создан Bitnami (https://bitnami.com/) и это один из нескольких написанных ими с открытым исходным кодом проектов, для поддержки лёгкой разработки приложений в кластере Kubernetes.

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

Они являются ключевым вкладчиком, наряду с Microsoft и Google, в Helm, который является диспетчером пакетов для Kubernetes, сопровождаемый форумом Cloud Native Computing Foundation , который, как мы знаем из Главы 2, Введение в Kubernetes, также сопровождает сам Kubernetes.

Сам Kubeless вы можете обнаружить на вебсайте http://kubeless.io/.

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

Большинство команд, которые мы собираемся применять, являются kubeless function. Это делает для нас доступными функции deploy, delete, edit и list. Кроме того мы можем исполнять наши функции при помощи call и проверки logs.

Далее мы имеем kubeless ingress; для этой команды мы можем create, delete и list маршруты к нашим функциям.

Наконец, мы также рассмотрим kubeless topic; как и ingress, она делает для нас доступными create, delete и listтемы, а также publish некое сообщение в какую- то тему.

Для начала мы собираемся рассмотреть две очень простые функции hello world. Первая из них просто печатает Hello World!, а вторая принимает некий ввод и затем отображает его вам обратно.

Прежде всего нам нужна наша функция. Статическая функция hello-world требует следующие три строки кода Python:

import json
def handler():
    return "Hello World!"
		

Поместите предыдущий код, который также доступен в нашей папке Chapter04/hello-world из репозитория GitHub, который сопровождает данную книгу, в файл с названием hello.py.

Теперь у нас имеется своя функция, которую мы можем развернуть в своём установленном по умолчанию пространстве имён, исполнив следующую команду:

$ kubeless function deploy hello \
  --from-file hello.py
  --handler hello.handler \
  --runtime python2.7 \
  --trigger-http
		

Данная команда создаёт некую функцию с названием hello при помощи файла hello.py. Всякий раз,когда исполняется функция с названием hello.handler, мы применяем python2.7 времени исполнения и наша функция устанавливается на переключение неким запросом http.

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

$ kubeless function ls
		

В нашей предыдущей команде имеется несколько колонок:

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

$ kubectl get functions
		

Исполнение этих команд должно выдать нечто подобное следующим результатам:

Теперь, когда мы имеем оснащённой свою функцию, мы можем исполнить её. Для этого выполните:

$ kubeless function call hello
		

Что выдаст следующий результат:

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

$ minikube service ui --namespace kubeless
		

После открытия вы должны увидеть свою функцию hello перечисленной с левой стороны. Кликнув по hello вы увидите сам код этой функции, а также имеется кнопка, озаглавленная RUN FUNCTION с правой стороны; кликнув по ней вы исполните свою функцию hello и возвратит Hello World!:

Окончательный способ, которым мы можем взаимодействовать с нашей функцией состоит в создании некоторого правила Ingress (проникновение); однако, прежде чем мы это сделаем, нам необходимо включить такое добавление Ingress в Minikube. Для этого исполните следующую команду:

$ minikube addons enable ingress
		

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

$ kubeless ingress create --function hello hello-ingress
		

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

$ kubeless ingress ls
		

Она выдаст информацию о том маршруте к Ingress, который мы создали, в том числе сам хост который мы будем иметь возможность применять для доступа к этой службе. в моём случае это http://hello.192.168.99.100.nip.io/.

Открытие этого URL в моём браузере возвращает Hello World!, так как исполняет его через HTTPie, который объяснялся в Главе 1, Ландшафт без серверов, как вы можете это увидеть из моего следующего вывода в Терминале:

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

Сам код для нашей новой функции всё ещё достаточно простой:

import json

def handler(context):
    print context.json
    return context.json
		<

Всё что делает данный код, так это получение того JSON, который мы ему отправляем и отображает его нам обратно. Поместите его в файл с названием hello-name.py или воспользуйтесь тем, что находится в папке Chapter04/hello-world/ в нашем репозитории GitHub. Когда у вас будет в наличии этот файл, вы сможете создать необходимую функцию, выполнив:

$ kubeless function deploy hello-name \
  --from-file hello-name.py \
  --handler hello-name.handler \
  --runtime python2.7 \
  --trigger-http
		

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

$ kubeless function ls
		

Вы должны увидеть перечисленными две функции, hello и hello-name. Теперь, когда мы создали свою новую функцию, мы можем вызвать её исполнив:

$ kubeless function call hello-name --data '{ "name": "Russ" }'
		

Отметим, что на этот раз мы применяем флаг --data для передачи данных в свою функцию. Исполнив все приведённые команды вы должны увидеть что- то аналогичное следующему выводе Терминала:

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

$ minikube service ui --namespace kubeless
		

После его открытия кликните на свою функцию hello-name. Прежде чем кликнуть по соответствующей кнопке RUN FUNCTION, замените GET на POST применив имеющееся ниспадающее меню, а в форме Request введите следующее:

{ "name": "Russ" }
		

Теперь кликните по кнопке RUN FUNCTION. Это действие возвратит тот же самый результат, что и команда kubeless function call:

Также мы можем взаимодействовать со своей службой напрямую, настроив некий маршрут Ingress:

$ kubeless ingress create --function hello-name hello-name-ingress
$ kubeless ingress list
		

Это выдаст вам ваши URL для обеих ваших функций:

В отличии от нашего первого примера, переход к имеющемуся URL для hello-name, которым в моём случае была http://hello-name.192.168.99.100.nip.io/, выдаст Error: 500 Internal Server Error (или в самых последних версиях Kubeless, некий 504 Gateway timeout):

Почему это происходит, ведь только что всё работало без ошибок, когда мы вызывали это с помощью команды kubeless function call, а также с применением своего веб интерфейса Kubeless?

Итак, просто вводя свою URL в браузер мы не передаём никаких данных для их возврата своей функцией. Мы можем убедиться в этом, проверив свой журнал регистраций. Для этого обновите свою страницу в браузере несколько раз, а затем выполните следующую команду:

$ kubeless function logs hello-name
		

Вы должны увидеть нечто подобное приводимому ниже:

Самая первая строка предыдущего вывода журнала регистраций является внутренней проверкой жизнеспособности, которая является успешной, так как было выработано состояние 200, которое вы можете обнаружить после GET. Следующие несколько строк содержат преследующие нас ошибки, ма получили некий Traceback и после него следующее: TypeError: handler() takes exactly 1 argument (0 given). Это означает, что данная функция ожидала передаваемых ей данных, но не получила их. Следующая строка является запросои нашего браузера; как вы можете видеть после выданного GET, имеется состояние 500.

Итак, как мы можем взаимодействовать со своей функцией, которая требует от нас POST данных вместо GET? Имеется несколько вариантов с помощью которых вы можете достичь этого в командной строке macOS и Linux, однако в Windows вам придётся исполнить ещё кое- что. Вместо того чтобы работать с различными вариантами, я собираюсь установить кусочек программного обеспечения, именуемого Postman (Почтальон). Это программное обеспечение рабочих мест работает во всех трёх рассматриваемых нами в этой книге операционных системах и оно предложит нам великолепный графический интерфейс для взаимодействия как с нашей функцией hello-name, так и со всеми прочими запускаемыми нами функциями.

Для установки Postman в macOS 10.13 High Sierra с помощью Homebrew просто исполните:

$ brew cask install postman
		

Для Postman имеется пакет в Chocolatey, поэтому если вы применяеете Windows 10 Professional, вы можете выполнить:

$ choco install postman
		

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

$ wget https://dl.pstmn.io/download/latest/linux64 -O postman.tar.gz
$ sudo tar -xzf postman.tar.gz -C /opt
$ rm postman.tar.gz
$ sudo ln -s /opt/Postman/Postman /usr/bin/postman1
   
Теперь у нас имеются нужные файлы в правильном месте, мы можем создать некий запуск рабочего стола для них исполнив:
		

$ cat > ~/.local/share/applications/postman.desktop <<EOL

[Desktop Entry]
Encoding=UTF-8
Name=Postman
Exec=postman
Icon=/opt/Postman/resources/app/assets/icon.png
Terminal=false
Type=Application

Categories=Development;
EOL
		
   
После того, как вы создали этот запуск, вы должны увидеть появившейся в перечне установленного программного обеспечения иконку Postman.
   
Сейчас, когда у нас имеется установленным Postman, откройте его и вас поприветствует экран с запросом на подпись. Это решение зависит от вас - 
   подписываться на него или нет - данная служба бесплатна и вы найдёте её великолепной если вам необходимо проверять отправку данных в некие 
   API. После того как вы пройдёте опции Sign up или Sign in, вам будет представлен экран, который выглядит следующим образом:
		

Кликните по опции Request под BUILDING BLOCKS; это приведёт вас к диалогу сохранения.Внём введите название своего Запроса, hello-name, а затем кликните по +Create Collection. Здесь создайте некую Коллекцию с названием Kubeless, а потом кликните Save для кнопки Kubeless.

Прежде всего, воспользовавшись ниспадающим меню замените GET на POST, затем в пространстве, помеченном как Enter request URL, введите http://hello-name.192.168.99.100.nip.io (или вашу URL, если она отличается). Теперь, когда мы определили что мы собираемся отправлять данные, нам нужно предоставить Postman реальные данные, которые следует отправить в нашу функцию.

Для ввода данных кликните по Body, а затем выберите вариант raw (сырые данные). КОгда вы выбираете raw, ваше поле ввода изменится и вы должны обнаружить слово Text со следующей за ним иконкой ниспадающего меню. Кликните по ней и отметьте соответствующую опцию для JSON (application/json). После изменения введите в основное поле следующее:

{
"name": "Russ"
}
		

Теперь, когда Postman настроен для POST (отправки) данных JSON в нашу функцию, вы можете кликнуть по Send. Это отправит определённые нами данные и затем отобразит полученные результаты в нижней части нашего экрана, одновременно с состоянием HTTP и значением времени, затраченного на исполнение нашего запроса, в точности как на приводимом ниже снимке экрана:

Нажатие на кнопку Save запомнит все установки, если вы пожелаете выполнить их повторно.

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

$ kubeless ingress delete hello
$ kubeless function delete hello
$ kubeless ingress delete hello-name
$ kubeless function delete hello-name
		

Эти команды удалят обе наши функции hello world functions и маршруты Ingress. Вы также можете повторно убедиться, что в наших веб интерфейсе Kubeless и инструментальной панели Kubernetes: и снова, вы можете открыть их с помощью:

$ minikube service ui --namespace kubeless
$ minikube dashboard
		

Если вы заметили что- то пропущенным либо для hello, либо для hello-name, вы можете удалить эти службы, поды и даже маршруты Ingress из своей инструментальной панели.

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

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

Если у вас имеется это, пройдите на страницу приложений Twitter по адресу https://apps.twitter.com/, где вам будет представлена для заполнения форма (Подробности приложения - Application Details), я применяю следующую информацию, однако несколько полей должны быть уникальными для вас и они помечены звёздочкой^*:

После того, как вы заполните всю предыдущую информацию, кликните по кнопке Create your Twitter application. Когда ваше приложение будет создано, вы окажетесь на странице, которая позволит вам управлять вашим приложением. Одной из закладок на этой странице является Keys and Access Tokens; нажатие на неё воспроизведёт для вас ваш Ключ потребителя (Consumer Key - API Key) и Секрентый код потребителя (Consumer Secret - API Secret). Перепишите их себе.

В нижней части этой страницы вы имеете кнопку, которая позволяет вам создавать Маркер доступа и Секретный маркер доступа (Access Token и Access Token Secret) для вашей учётной записи; нажатие по этой кнопке создаст вам необходимые маркеры - и снова перепишите их себе.

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

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

$ kubectl create secret generic twitter \
  --from-literal=consumer_key=YOUR_CONSUMER_KEY \
  --from-literal=consumer_secret=YOUR_CONSUMER_SECRET \
  --from-literal=token_key=YOUR_TOKEN_KEY \
  --from-literal=token_secret=YOUR_TOKEN_SECRET
		

В моём случае данная команда выглядит следующим образом:

Она создаёт секретный код, именуемый как twitter, который содержит наши четыре различных ключа и марвера, которые мы передали в свою команду. Вы можете вывести список своих секретных кодов исполнив:

$ kubectl get secret
		

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

Имеются три определённых по умолчанию маркера учётной записи Kubernetes, которые содержат три элемента, а также наш секретный код twitter, включающий в себя наши четыре ключа и маркера. Также вы можете отслеживать секретные коды в своей инструментальной панели Kubernetes:

Как вы можете видеть из предыдущего снимка экрана, у вас также имеется опция выявления (revealing) самого секретного кода через нажатие на икноку глаза.

На данный момент у нас имеется своя подготовленная среда, в которой мы можем выполнять оснащение необходимой функции. Для этого нам понадобятся два файла; первый из них это файл requirements.txt и он содержит всего две строки:

python-twitter
kubernetes==2.0.0
		

Этот файл requirements.txt даёт знать Python какие внешние библиотеки развёртывать помимо нашего кода. В своём файле мы применяем библиотеку twitter, поэтому мы можем легко отправлять свои твиты, а также библиотеку kubernetes для декодирования созданных нами в предыдущем разделе секретных кодов. Применение этих библиотек означает, что наш код достаточно модернезирован, поскольку вся тяжёлая работа осуществляется внутри нашей функции ядра. Сам код для данной функции выглядит так:

import base64
import twitter

from kubernetes import client, config

config.load_incluster_config()

v1=client.CoreV1Api()

for secrets in v1.list_secret_for_all_namespaces().items:
    if secrets.metadata.name == 'twitter':
        consumer_key = base64.b64decode(secrets.data['consumer_key'])
        consumer_secret = base64.b64decode(secrets.data['consumer_secret'])
        token_key = base64.b64decode(secrets.data['token_key'])
        token_secret = base64.b64decode(secrets.data['token_secret'])

api = twitter.Api(consumer_key=consumer_key,
                  consumer_secret=consumer_secret,
                  access_token_key=token_key,
                  access_token_secret=token_secret)

def handler(context):
    msg = context.json
    status = api.PostUpdate(msg['tweet'])
		

Поместите его в файл под названием tweet.py. Как и ранее, и файл requirements.txt, и файл tweet.py можно отыскать в нашем репозитории GitHub в Chapter04/twitter/.

Сама команда оснащения нашей функции имеет одно добавление к применявшейся ранее команде развёртывания. Поскольку теперь мы можем загружать внешние библиотеки, нам необходимо позволить Kubeless знать что мы желаем применять файл requirements.txt, добавив соответствующий флаг --dependencies:

$ kubeless function deploy twitter \
  --from-file tweet.py \
  --handler tweet.handler \
  --runtime python2.7 \
  --trigger-http \
  --dependencies requirements.txt
		

Как вы можете увидеть из приводимого ниже вывода терминала, эти зависимости теперь перечисляются при исполнении команды kubeless function list:

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

$ kubeless function call twitter --data '{"tweet": "Testing twitter function from Kubeless!"}'
		

Вы не получите обратно никакого отклика, однако если вы пройдёте в свою учётную запись Twitter, вы должны обнаружить свой твит:

Для отправки твитов вы также можете применять Postman. Прежде всего создайте некий маршрут Ingress выполнив такие команды:

$ kubeless ingress create --function twitter twitter-ingress
$ kubeless ingress list
		

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

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

$ kubeless ingress create --function twitter twitter-ingress
$ kubeless ingress list
		

Кликнув по Send мы отправим свой твит и, как и в случае вызова своей функции применяем команду kubeless function call, которая не возвратит нам никакого отклика.

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

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

$ kubeless function delete twitter
$ kubeless ingress delete twitter-ingress
$ kubectl delete secret twitter
		

Кроме того, если вам это надо, вам следует вернуться в https://apps.twitter.com/ и либо удалить, либо аннулировать своё приложение или маркеры.

Возвращаясь назад, к Главе 1, Ландшафт без серверов, в которой мы устанавливали инфраструктуру Serverless для развёртывания какой- то функции AWS Lambda; работа без сервера также может осуществляться и в Kubeless.

Если вы ещё пока не установили безсерверное решение (serverless), приведём краткое повторение того как его установить в трёх рассматриваемых нами операционных системах.

Для macOS 10.13 High Sierra выполните следующую команду для установки Node.js с помощью Homebrew:

$ brew install node
		

Если вы применяете Windows 10 Professional, тогда вы можете установить Node.js применяя Chocolatey, исполнив:

$ choco install nodejs
		

Наконец, если вы применяете Ubuntu 17.04, вы можете установить Node.js с помощью следующих команд:

$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
$ sudo apt-get install -y nodejs
		

Сейчас, когда самая последняя версия Node.js установлена, мы можем воспользоваться Node Package Manager (NPM) для установки serverless исполнив:

$ npm install -g serverless
		

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

$ serverless login
		

Теперь, после установки serverless, мы можем запустить определённую демонстрацию функции Kubeless выполнив следующие команды:

$ serverless create --template kubeless-python --path new-project
$ cd new-project
$ npm install
		

Если вы не пройдёте далее, запуск этих команд приводит к следующему результату:

Наши команды установили встраиваемый модуль serverless Kubeless и создаёт тот файл serverless.yml, который определяет нашу функцию. Он содержит следующее:

service: new-project

provider:
  name: kubeless
  runtime: python2.7

plugins:
  - serverless-kubeless

functions:
  hello:
    handler: handler.hello
		

Как вы можете видеть, данный код сообщает serverless, что мы применяем Kubeless и что он обязан применять встраиваемый модуль Kubeless. Он также определяет некую функцию, а также обработчик с названием hello. Эту функцию можно отыскать в файле handler.py. Он содержит приводимый ниже код и он достаточно схож с нашими примерами hello-world, которые мы видели ранее в этой главе:

import json


def hello(request):
    body = {
        "message": "Go Serverless v1.0! Your function executed successfully!",
        "input": request.json
    }

    response = {
        "statusCode": 200,
        "body": json.dumps(body)
    }

    return response
		

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

$ serverless deploy -v
		

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

$ serverless deploy function -f hello
		

Применение самого serverless для вызова данной функции может привести в результате к какой- то ошибке, как приводимая ниже, не беспокойтесь:

$ serverless invoke --function hello --data '{"Kubeless": "Welcome!"}' -l
		

Мы всё ещё можем осуществлять доступ к своей функции, применяя Kubeless:

$ kubeless function list
$ kubeless function call hello --data '{"Kubeless": "Welcome!"}'
		

Эти команды возвращают следующий результат:

Для удаления нашего примера функции, исполните следующую команду:

$ serverless remove
		

Прежде чем мы завершим данную главу, давайте взглянем на некий пример, который применяет события, отличные от HTTP. В папке Chapter04/serverless-event/ нашего репозитория GitHub имеется некий пример приложения, который ожидает (listens) события.

Данный файл serverless.yml отличается от нашего предыдущего примера HTTP, в том, что помимо обработчика он добавляет некий раздел событий, который содержит необходимые переключатели/ темы (trigger/topic):

service: events

provider:
  name: kubeless
  runtime: python2.7

plugins:
  - serverless-kubeless

functions:
  events:
    handler: handler.events
    events:
      - trigger: 'hello_topic'
		

Наш файл handler.py содержит вероятно самый простой код из всех наблюдавшихся нами до сих пор:

def events(context):
    return context
		

Чтобы запустить данный пример, просто исполните следующие команды из нашей папки Chapter04/serverless-event/:

$ npm install
$ serverless deploy -v
$ kubeless function list
		

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

$ kubeless topic publish --topic hello_topic --data 'testing an event!'
$ kubeless topic publish --topic hello_topic --data 'and another event!'
		

Наконец, мы можем проверить свой журнал чтобы увидеть те два события, которые произошли в результате исполнения:

$ serverless logs -f events
		

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

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

$ minikube delete
		

В данной главе мы развернули Kubeless в своём Kubernetes из одного узла, который мы запустили при помощи Minikube. Мы установили клиента командной строки Kubernetes, а также интерфейс на основе веб протокола. После того как кластер был развёрнут, а инструменты установлены, мы развернули и исполнили функции в своей установке Kubeless.

Мы освоили установку двух базовых тестовых функций, прежде чем установили более полезную функцию, которая отправляет твиты. Затем мы рассмотрели как мы можем взаимодействовать с Kubeless при помощи инфраструктуры Serverless.

В своей следующей главе мы собираемся рассмотреть инфраструктуру на основе событий с названием Funktion.