05.06.2023 в 14:00

Микросервисы с pebl — полноценной и бесплатной облачной платформой

В этом руководстве я хочу представить pebl, полноценную и бесплатную облачную платформу.

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

Начало работы

Регистрация

Итак, сначала нам нужно зарегистрировать бесплатную учетную запись на pebl.io.

Выберите нужного вам поставщика удостоверений личности и следуйте инструкциям. И обязательно зарегистрируйте свой бесплатный поддомен *.pebl.rocks! Мы будем использовать это в оставшейся части урока.

Docker и pebl CLI

Для pebl есть только два системных требования: Docker и интерфейс командной строки pebl. Если у вас не установлен Docker, перейдите на веб-сайт докеров и следуйте их указаниям.

Для pebl CLI выберите правильную ссылку в документации по настройке pebl. Убедитесь, что вы выбрали правильную ссылку для загрузки для вашей собственной системы! Если вы используете Mac, вы можете проверить, является ли ваша система Intel или M1, перейдя в меню Apple, а затем «Об этом Mac».

Убедитесь, что CLI был установлен правильно, запустив pebl без каких-либо аргументов:

$ pebl
usage:

    pebl {command}

available commands:

       up  start the local pebl cluster.
     down  stop the local pebl cluster.
     info  attach and show info about the local pebl cluster.
      run  execute a pebl program locally.
   deploy  execute a pebl program in the cloud.
   tunnel  creates a tunnel to a redis instance.
     auth  manages the credentials needed for certain commands.
  version  print the version of the cli.

$

Простой сервис

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

Теперь давайте погрузимся в pebl, создав очень простой сервис с помощью Python.

Hello World!

Создайте папку scratch project где-нибудь в вашей системе. В наших примерах мы будем использовать ~/work/scratch:

$ mkdir -p ~/work/scratch

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

Теперь давайте создадим подпапку, которая будет содержать наш простой сервис hello world.

mkdir ~/work/scratch/hello

Создайте main.py (~/work/scratch/hello/main.py), который будет содержать основной метод, и вставьте следующее:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def root():
    return "hello, world!\n"

import pebl
pebl.service(app, "hey.pebl.rocks")  # put your own domain here

Первый раздел main.py должен выглядеть очень знакомо, если вы раньше использовали Flask. Это очень простое определение Flask с одним обработчиком на корневом пути. В последних двух строках мы объявляем, что это приложение Flask должно быть службой, размещенной на вашей конечной точке *.pebl.rocks.

На этом этапе вы можете ожидать, что нам нужно создать отдельный yaml для pebl. Но на самом деле этого единственного вызова метода достаточно, чтобы определить службу с помощью pebl! Итак, резюмируя:

Облачные возможности (pebl.service) встроены в приложение в виде обычного кода
Вы можете положиться на любую другую библиотеку Python без дополнительной настройки, например Flask

Теперь, чтобы воспроизвести это, мы будем собираться на базовом образе Docker от pebl для создания повторно используемого контейнера. Идите вперед и создайте файл Dockerfile (~/work/scratch/hello/Dockerfile) с предложением содержимым:

FROM peblcloud/python
COPY . .
RUN pip install flask
ENTRYPOINT python -u main.py

Локальная среда выполнения

Pebl позволяет выполнять ваш код локально, чтобы гарантировать правильность и обеспечить сверхбыстрый цикл итераций. Сначала запустите локальный кластер, который будет содержать все наши локальные рабочие нагрузки с pebl up:

$ pebl up
 :: initializing new pebl cluster...
 :: done!
 :: run `pebl info` to see logs, endpoints, and other info about the running cluster!
$

После настройки кластера перейдите в подпапку hello и выполните pebl run:

$ cd ~/work/scratch/hello
$ pebl run
 :: building docker project...
 :: starting container...
$

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

Вы должны увидеть что-то вроде этого, но с собственным поддоменом *.pebl.rocks вместо hey.pebl.rocks. Попробуйте отправить запрос на ваш сервер.

$ curl localhost:32807
hello, world!
$

Убедитесь, что вы указали правильный порт, как показано на панели информации!

Облачная среда выполнения

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

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

Таким образом, pebl позволяет очень легко перенести ваши приложения в облако после того, как вы закончите их локальное тестирование. Просто запустите pebl deploy аналогично pebl run:

$ cd ~/work/scratch/hello
$ pebl deploy

Если вы получаете ошибки аутентификации, обязательно запустите pebl auth и следуйте инструкциям!

После успешного развертывания попробуйте отправить запрос с помощью curl. Обязательно используйте https, так как все службы в облаке по умолчанию получают TLS, а pebl запрещает трафик без TLS.

$ curl https://hey.pebl.rocks
hello, world!
$

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

Микросервисы

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

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

Итак, в этом разделе мы рассмотрим добавление внутренней службы и использование Go вместо Python, чтобы подчеркнуть независимую от языка функцию pebl.

Переходим к настройке

Давайте создадим подпапку в нашей рабочей папке для хранения нашей настройки Go.

$ mkdir ~/work/scratch/go

Затем инициализируйте проект Go с помощью go mod init:

$ cd ~/work/scratch/go
$ go mod init scratch

И в отличие от Python, поскольку Go скомпилирован, нам на самом деле не нужен Dockerfile. Вместо этого нам нужно загрузить пакет perl для Go:

$ cd ~/work/scratch/go
$ go get github.com/peblcloud/go

Пользовательские сервисы

И чтобы мотивировать реальное использование, мы создадим внутренний сервис Go, который действует как пользовательский сервис, отвечающий за управление пользовательскими данными. Создайте main.go (~/work/scratch/go/main.go):

package main

import (
    "github.com/peblcloud/go"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("this is an internal service!\n"))
    })

    pebl.InternalService(mux, "go.internal")
}

Так же, как мы делали ранее с Python, мы создаем объект сервера на основе файла net/http. Затем передать сконфигурированный серверный объект в SDK pebl с помощью вызова pebl.InternalService.

Обратите внимание, что в отличие от службы, которую мы определили ранее, мы предоставляем недействительный домен go.internal. Для внутренних служб конечной точкой может быть что угодно, хотя мы рекомендуем вам использовать простую для запоминания схему, такую как .local или .internal TLD.

Давайте попробуем запустить это! Как и раньше, выполните pebl run, чтобы запустить его локально:

$ cd ~/work/scratch/go
$ pebl run
 :: building golang project...
 :: staging build at: /var/folders/92/_vg8jtqx7kncxb_9jlpw8rmm0000gn/T/3019178735
 :: containerizing the build...
 :: starting container...
$

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

Вы можете отправлять запросы на эту новую внутреннюю конечную точку с помощью curl:

$ curl localhost:32808
this is an internal service!
$

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

Redis

Теперь наш внутренний сервис Go не очень интересен, потому что он ничего не делает на основе нашего запроса. Чтобы поддерживать гораздо более широкий набор приложений, pebl обеспечивает постоянство через Redis. И так же, как мы делали до сих пор, мы разблокируем эту возможность через SDK.

Итак, давайте обновим сервис Go (~/work/scratch/go/main.go), включив Redis.

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"

    "github.com/peblcloud/go"
    "github.com/redis/go-redis/v9"
)

func main() {
    connInfo, _ := pebl.Redis("users")
    client := redis.NewClient(&redis.Options{
        Addr: fmt.Sprintf("%s:%d", connInfo.Host, connInfo.Port),
    })

    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        query, _ := url.ParseQuery(r.URL.RawQuery)
        name := query.Get("name")
        userInfo, _ := client.HGetAll(context.Background(), name).Result()
        payload, _ := json.Marshal(userInfo)
        w.Write(payload)
    })

    pebl.InternalService(mux, "go.internal")
}

Затем обновите зависимости нашего модуля, запустив go mod tidy, который должен автоматически открыть github.com/redis/go-redis/v9. Если по какой-то причине это не работает, вы можете вручную запустить go get github.com/redis/go-redis/v9.

Теперь запустите этот сервис Go, выполнив pebl run внутри ~/work/scratch/go/. На вашей информационной панели теперь должен быть указан экземпляр Redis, который мы используем с именованными пользователями.

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

$ curl 'localhost:32808?name=alice'
{}
$ curl 'localhost:32808?name=bob'
{}

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

$ redis-cli -p 32809
127.0.0.1:32809> hset alice name alice email alice@example.org
(integer) 2
127.0.0.1:32809> hset bob name bob email bob@example.org
(integer) 2

Теперь, когда вы отправляете запросы с alice или bob в качестве запроса, вы получите их информацию о пользователе json в ответе:

$ curl 'localhost:32808?name=alice'
{"email":"alice@example.org","name":"alice"}
$

Прокси-сервер

Теперь, чтобы использовать эту внутреннюю службу, мы будем передавать подмножество запросов из нашей внешней службы Python в нашу внутреннюю службу Go. Давайте обновим наш main.py в папке ~/work/scratch/hello/:

from flask import Flask
import requests

app = Flask(__name__)

@app.route("/")
def root():
    return "hello, world!\n"

@app.route("/user/<name>")
def user_service(name):
    r = requests.get(f"http://go.internal?name={name}")
    return r.text, r.status_code

import pebl
pebl.service(app, "hey.pebl.rocks")  # put your own domain here

Итак, здесь мы полагаемся на популярную библиотеку запросов, чтобы отправлять запросы /user во внутреннюю службу Go по адресу go.internal:80. И снова сила pebl заключается в возможности легко включать другие библиотеки Python без какой-либо внешней настройки. Но прежде чем мы сможем запустить это локально, нам нужно убедиться, что библиотека запросов доступна для использования в контейнере. Итак, обновите Dockerfile:

FROM peblcloud/python
COPY . .
RUN pip install flask requests
ENTRYPOINT python -u main.py

Давай, попробуй запустить это! Вы сможете запросить внешнюю конечную точку по пути /user, чтобы получить доступ к внутренней службе:

$ curl localhost:32807/user/alice
{"email":"alice@example.org","name":"alice"}
$ curl localhost:32807/user/bob
{"email":"bob@example.org","name":"bob"}
$

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

Приступайте к развертыванию этих изменений! Сначала разверните внутреннюю службу Go:

$ cd ~/work/scratch/go
$ pebl deploy

Затем снова вызовите pebl deploy в подпроекте python:

$ cd ~/work/scratch/hello
$ pebl deploy

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

$ curl https://hey.pebl.rocks/user/alice
{}
$ curl https://hey.pebl.rocks/user/bob
{}

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

Управление Redis

Чтобы получить доступ к Redis, который находится в облачной среде выполнения, мы можем использовать команду pebl tunnel pebl CLI:

$ pebl tunnel
 :: tunnel established at: 127.0.0.1:59039
 :: use redis-cli to connect:
 :: redis-cli -p 59039

Этот туннель проксирует локальный трафик на ваши экземпляры Redis в облаке. Вы можете использовать redis-cli с аргументом -p для подключения к проксируемому порту и установить те же данные, которые мы использовали локально:

$ redis-cli -p 59039
127.0.0.1:59039> hset alice name alice email alice@example.org
(integer) 2
127.0.0.1:59039> hset bob name bob email bob@example.org
(integer) 2

Теперь ваши запросы к облаку будут возвращать те же результаты, что и раньше:

$ curl https://hey.pebl.rocks/user/alice
{"email":"alice@example.org","name":"alice"}
$ curl https://hey.pebl.rocks/user/bob
{"email":"bob@example.org","name":"bob"}

Итак, мы рассмотрели три возможности pebl — сервисы, внутренние сервисы и Redis.

Источник:

Comment button

#Redis

Войти на сайт