Начало работы с Native 2020

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

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

Основная причина, по которой я создал этот пост в блоге, заключается в том, чтобы убедиться, что разработчики Java, такие как я, могут установить и понять основы Knative с помощью простых примеров, чтобы я мог предоставить более продвинутые сообщения в блоге о том, как Zeebe ( http://zeebe.io ) Интеграция Knative будет работать, основные причины, лежащие в ее основе, и как вы можете воспользоваться ею.

В этом посте в блоге вы узнаете:

Как начать работу с Native в вашем собственном кластере
Как развернуть и взаимодействовать с простым встроенным сервисом с конечной точкой HTTP,
Отправка/получение облачных событий с использованием HTTP-транспорта
Напишите приложения Spring Boot + Spring Cloud Streams, которые обмениваются данными, отправляя облачные события с помощью Kafka

Существует несколько способов установки Native, и большинство из них зависят от Istio. В этом сообщении в блоге я решил использовать glooctl для простоты и использования того факта, что он использует меньше ресурсов. glooctl заменяет Edition на Gloom, который представляет собой легкий контроллер входа и предоставляет все функции, необходимые Knative. В качестве альтернативы вы можете установить Native из официальной документации проекта: https://knative.dev/docs/install/

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

Если вы работаете на Mac OSX, вы можете установить glooctl с помощью brew:

заварить установку solo-io/tap/glooctl

Как только у вас будет glooctl и запущенный кластер Kubernetes, доступный с помощью kubectl ,

glooctl установить knative -g -e.12.0

Как только Native установлен, нам нужно установить Gloom в качестве шлюза API для маршрутизации трафика из-за пределов кластера к нашим рабочим нагрузкам Knative. Мы делаем это, используя их схемы управления:

репозиторий helm добавляет мрачности https://storage.googleapis.com/solo-public-helm

обновление репозитория helm

Давайте создадим новое пространство имен для Gloom и установим там диаграмму управления:

kubectl создает пространство имен gloo-system

рулевой установит gloo gloo/gloo –пространство имен gloo-system -f values.yaml

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

gateway: 
  enabled: false 
  settings: 
    integrations: 
      knative: 
        enabled: true 
        version: 0.12.0

Благодаря этому теперь у вас есть контроллер входа Gloo, а также собственное обслуживание и события, запущенные и запущенные.

Файлы, перечисленные здесь и в других разделах, можно найти в этом репозитории GitHub: https://github.com/salaboy/knative-getting-started-java-resources

Мы только что установили Встроенное обслуживание и Встроенное событие в наш кластер Kubernetes.

Собственное обслуживание обеспечивает уровень абстракции поверх развертывания и входа служб Kubernetes.

Нативное обслуживание обычно упоминается, когда люди говорят о бессерверном обслуживании поверх Kubernetes, поскольку оно предоставляет нашим приложениям функции нулевого масштаба из коробки, чего нельзя достичь с помощью простого Kubernetes. Основная концепция обслуживания на родном языке – это Обслуживание на родном языке. Поначалу я был совершенно сбит с толку выбором названия. Зачем называть это сервисом, если в Kubernetes уже есть ресурс с именем Service? Вы можете рассматривать собственную службу как службу Kubernetes + Развертывание + Вход на стероидах. Собственный сервис предоставляет нам высокоуровневую концепцию для создания облачных приложений, не беспокоясь обо всех низкоуровневых компонентах, необходимых в Kubernetes для развертывания и доступа к нашим приложениям.

Собственные сервисы, например, используют автоматическое масштабирование, которое позволяет масштабировать наши сервисы в зависимости от спроса. Возможность уменьшения масштаба наших сервисов до нуля, когда они не используются – вы заметите, что из-за этого термин “бессерверный” довольно часто используется на сайте Knative. Кроме того, он обеспечивает автоматические моментальные снимки нашего развернутого кода и конфигураций в определенный момент времени, предварительную маршрутизацию трафика, построенную поверх сервисной сетки.

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

Если вы такой же разработчик Java, как я, то внедрение сервисов или микросервисов – это то, что мы делаем, создавая приложения Spring Boot, эти приложения будут нашими основными сервисами. Если мы создаем масштабируемые системы с высокой степенью масштабируемости, то для передачи наших услуг довольно часто приходится полагаться на инфраструктуру обмена сообщениями. Инструменты обмена сообщениями, такие как Kafka, RabbitMQ и другие, предоставляют нашим сервисам гарантии доставки сообщений и готовый механизм повторных попыток, когда что-то идет не так. В дополнение к Spring Boot у нас есть такие фреймворки, как Spring Cloud Streams , которые облегчили нашу жизнь, абстрагируя все низкоуровневые детали, которые нам нужно знать при использовании этих инструментов обмена сообщениями (Kafka, RabbitMQ, Google PubSub и т.д.). Это подталкивает нас к пониманию того, как такие фреймворки, как Spring Cloud Streams, будут работать с собственным Eventing, поэтому давайте испачкаем руки некоторыми примерами, которые вы можете запустить в своем кластере.

Теперь у нас есть Native, установленный с помощью Gloom, давайте попробуем, создав простой пример. Как обычно, для любого развертывания Kubernetes нам нужно будет создать наше приложение, а затем образ Docker а затем несколько файлов YAML для развертывания нашего приложения в кластере. Мы будем помещать эти изображения Docker в http://hub.docker.com так что вам нужно будет завести там учетную запись.

Репозиторий здесь: Репозиторий здесь:

Простое приложение Spring Boot на Java, которое предоставляет конечную точку REST

@SpringBootApplication
@RestController
public class KnativeHelloWorldApplication {
... 
  @GetMapping("/{name}") 
  public String hello(@PathVariable("name") String name) { 
    return "Hello there Knative Traveller: " + name; 
  }
...
}

Нам нужно скомпилировать этот проект с

чистый пакет mvn

Чтобы сгенерировать fat-jar в каталоге target/ .

Самый простой Dockerfile с использованием OpenJDK:11 slim

Файл Dockerfile

FROM openjdk:11-jre-slim
COPY target/\*.jar /app.jar
CMD ["java", "-jar", "app.jar"]

Нам нужно создать образ docker с помощью:

сборка докера -t/native-hello-world .

А затем нажмите на docker hub с помощью

docker push/knative-привет, мир

И вот тут Native начинает помогать нам сосредоточиться на нашей бизнес-логике вместо того, чтобы писать тонны файлов YAML для Kubernetes. Для Native нам просто нужен единый манифест службы Knative:

Для Native нам просто нужен единый манифест службы Knative:

apiVersion: serving.knative.dev/v1
kind: Service
metadata: 
  name: knative-hello-world
spec: 
  template: 
    spec: 
      containers: 
      - image: salaboy/knative-hello-world

kubectl apply -f service.yaml

Когда создается Собственная служба, Native автоматически создает другие ресурсы (Конфигурацию, маршрут и ревизию), включая службу Kubernetes, Развертывание и Вход. На родной стороне автоматически создаются следующие ресурсы:

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

Этот собственный сервис будет автоматически уменьшен до 0, если после 90 секунд бездействия в сервис не поступает трафик.

Взаимодействие с нашим новым собственным сервисом

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

kubectl получить svc

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

Но http://knative-hello-world.default.example.com определенно недоступен, так как мы, вероятно, не владеем доменом example.com . Чтобы найти внешний IP-адрес с нашего контроллера входа, мы можем запустить:

kubectl получает svc -A

Здесь должен быть указан knative-external-proxy , который является балансировщиком нагрузки и имеет внешний IP-адрес

балансировщик нагрузки gloo-system knative-external-proxy

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

curl -H “Ведущий: knative-hello-world.default.example.com ” http://<ВНЕШНИЙ IP>/salaboy -v

Обратите внимание: нам нужно включить заголовок Host только потому, что у нас нет общедоступного домена.

Завиток – Что? Почему?

Если вы работаете с облачным провайдером, который может предоставить балансировщику нагрузки общедоступный Ip-адрес, мы можем использовать XIP.io и настройте Gloo DNS для использования XIP.io адрес.

https://knative.dev/docs/install/knative-with-gloo/ -> Настройка DNS

kubectl редактировать cm config-домен –пространство имен, связанное с обслуживанием

И измените его так, чтобы он выглядел как this :

apiVersion: v1
kind: ConfigMap
metadata: 
  name: config-domain 
  namespace: knative-serving
data: 
# xip.io is a "magic" DNS provider, which resolves all DNS lookups for: 
# \*.{ip}.xip.io to {ip}. 
  .xip.io: ""

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

завиток http://knative-hello-world.default .<ВНЕШНИЙ IP>.xip.io/salaboy – в

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

Если мы разрабатываем распределенную систему, мы можем захотеть взаимодействовать между различными службами. Облачные события становятся популярным способом сделать это путем обмена данными в общем формате/конверте. К счастью для нас, Native Eventing уже поддерживает облачные события, и мы можем использовать это прямо сейчас. Собственное событие предоставляет нам набор компонентов, которые обеспечивают позднюю привязку для источников событий (производителей) и потребителей событий. Это означает, что мы можем создавать наших потребителей и производителей общим способом, а затем связывать их вместе во время выполнения.

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

Репозиторий здесь: Репозиторий здесь:

В Spring Boot вы сделаете что-то вроде это :

...
@PostMapping
public String recieveCloudEvent(@RequestHeader Map headers, @RequestBody Object body) { 
  CloudEvent cloudEvent = CloudEventsHelper.parseFromRequest(headers, body); 
...
}
...

Теперь мы можем отправить облачное событие с помощью curl, добавив правильные заголовки

столб для завивки http://knative-hello-world.default .<ВНЕШНИЙ IP>.xip.io -H “Тип содержимого: application/json” -H “ce-id: 536808d3” -H “ce-type: my-first-cloud-event” -H “ce-source: curl” -d ‘{“name”:”salaboy”}’ -v

Обратите внимание: ce-type: my-first-cloud-event который представляет, что это за событие. Мы можем использовать это, чтобы решить, заинтересованы мы в этом или нет. Как данные (отправляемые с помощью -d ), так и ce-type определяются пользователем. Облачные события не накладывают никаких ограничений на отправляемые данные.

Примечание: Тип содержимого: application/json , чтобы избежать отправки содержимого формы-данных.

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

Когда вы посмотрите на Native, вы обнаружите, что уже существует множество доступных источников событий, например, KubernetesEventSource , Источник на GitHub , GcpPubSubSource , AWSSQSSOURCE , Контейнерный источник , CronJobSource , Источник Кафки , Верблюжий источник .

Но давайте создадим нашего собственного производителя, еще одно приложение spring boot, которое просто отправляет облачное событие, публикуя контент по HTTP.

Репозиторий здесь: Репозиторий здесь:

Репозиторий здесь: ||

@SpringBootApplication
@RestController
public class KnativeEventProducerApplication {

  ...

    @Value("${SINK_HOST:localhost}")
    private String HOST;


    @GetMapping("/{name}")
    public String doSomethingAndSendCloudEvent(@PathVariable("name") String name) {

        final CloudEvent myCloudEvent = CloudEventBuilder.builder()
                .withId("ABC-123")
                .withType("my-first-cloud-event")
                .withSource(URI.create("knative-event-producer.default.svc.cluster.local"))
                .withData("{\"name\" : \"" + name + "-" + UUID.randomUUID().toString() + "\" }")
                .withDatacontenttype("application/json")
                .build();

        WebClient webClient = WebClient.builder().baseUrl(HOST).filter(logRequest()).build();

        WebClient.ResponseSpec postCloudEvent = CloudEventsHelper.createPostCloudEvent(webClient, myCloudEvent);

        postCloudEvent.bodyToMono(String.class).doOnError(t -> t.printStackTrace())
                .doOnSuccess(s -> System.out.println("Result -> " + s)).subscribe();

        return "OK!";

    }
...

Репозиторий здесь: ||

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: knative-event-producer
spec:
  template:
    spec:
      containers:
        - image: salaboy/knative-event-producer
          env:
            - name: SINK_HOST
              value: knative-hello-world.default..xip.io

Обратите внимание: теперь мы настраиваем SINK для событий, создаваемых в нашей службе, с помощью переменной среды с именем SINK_HOST и мы указываем на внутреннее DNS-имя для нашего сервиса knative-hello-world .

Если вы создадите проект, образ Docker, а затем примените этот манифест собственной службы, вы можете свернуть производителя событий, чтобы отправить CloudEvent в наш собственный сервис Hello World.

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

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

В этом сценарии у нас будет приложение, создающее сообщения Kafka, и мы хотим перенаправить содержимое этих сообщений на нашу конечную точку потребителя HTTP CloudEvent. Мы не разрабатывали ни одно из этих приложений для общения друг с другом, но поскольку мы используем облачные события (и полезные нагрузки JSON), теперь они могут обмениваться информацией.

Для того чтобы это заработало, нам нужно:

Установите Kafka или запустите его где-нибудь, где он доступен для кластера
Установите исходный код Kafka для Knative
Создайте источник Kafka для Native, чтобы понять, откуда поступают сообщения и куда они направляются. Это называется “поздней привязкой”, потому что вы меняете исходные файлы, создаете новые или удаляете их во время выполнения.
Создавать сообщения Кафки

Давайте установим Kafka в наш кластер с помощью Helm:

helm repo добавить инкубатор http://storage.googleapis.com/kubernetes-charts-incubator

рулевой установит инкубатор my-kafka/кафка

Далее нам нужно установить исходный код Kafka для Knative

kubectl применить -f https://storage.googleapis.com/knative-releases/eventing-contrib/latest/kafka-source.yaml

Теперь мы готовы создать наш исходный код Kafka с приемником, указывающим на наш собственный сервис knative-hello-world :

Теперь мы готовы создать наш исходный код Kafka с приемником, указывающим на наш || knative-hello-world || Собственный сервис: kafka-knative-source.yaml

apiVersion: sources.eventing.knative.dev/v1alpha1
kind: KafkaSource
metadata:
  name: kafka-source
spec:
  consumerGroup: knative-group
  bootstrapServers: my-kafka:9092 #note the kafka namespace
  topics: knative-topic
  sink:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: knative-hello-world

Теперь мы готовы создать наш источник Kafka с приемником, указывающим на наш native-hello-world Native Service: kafka-native-source.yaml Теперь мы можем отправлять сообщения в knative-topic , и они будут автоматически перенаправляться в нашу службу Knative под названием knative-hello-world . Теперь мы готовы создать наш исходный код Kafka с приемником, указывающим на наш

Теперь мы готовы создать наш источник Kafka с приемником, указывающим на наш || native-hello-world || Native Service: kafka-native-source.yaml Теперь мы можем отправлять сообщения в || knative-topic || и они будут автоматически перенаправляться в нашу службу Knative под названием || knative-hello-world. Обратите внимание, что || my-kafka || – это название службы Kubernetes. Очень ленивый способ отправлять сообщения в || knative-topic || mkubectl запустить kafka-producer -ti/kafka: 0.14.0-кафка-2.3.0 — bin/kafka-console-producer.sh –broker-list my-kafka:9092 –topic {Который отправит сообщение Kafka, которое будет преобразовано в облачное событие и перенаправлено в наше облако HTTP Даже в реальном проекте на самом деле не имеет значения, как вы создаете сообщение Kafka. t потребитель ( || познавательный-привет-мир || Познавательный сервис). “msg”: “Это тест!”} Затем введите сообщение в приглашении: knative-topic может использовать клиент Kafka из контейнера Docker, например: это было создано путем установки Kafka с помощью Helm. Теперь мы готовы создать наш источник Kafka с приемником, указывающим на наш || native-hello-world || Native Service: kafka-native-source.yaml Теперь мы можем отправлять сообщения в || knative-topic || и они будут автоматически перенаправляться в нашу службу Knative под названием || knative-hello-world. Обратите внимание, что || my-kafka || – это название службы Kubernetes. Очень ленивый способ отправлять сообщения в || knative-topic || mkubectl запустить kafka-producer -ti/kafka: 0.14.0-кафка-2.3.0 — bin/kafka-console-producer.sh –broker-list my-kafka:9092 –topic {Который отправит сообщение Kafka, которое будет преобразовано в облачное событие и перенаправлено в наше облако HTTP. Даже в реальном проекте действительно не имеет значения, как вы создаете, одним из вариантов было бы просто захватить API-интерфейсы Kafka Java и заставить ваше приложение записывать сообщения в предыдущую тему Kafka. электронное сообщение Кафки. t потребитель ( || познавательный-привет-мир || Познавательный сервис). “msg”: “Это тест!”} Затем введите сообщение в приглашении: knative-topic может использовать клиент Kafka из контейнера Docker, например: это было создано путем установки Kafka с помощью Helm. Теперь мы готовы создать наш источник Kafka с приемником, указывающим на наш || native-hello-world || Native Service: kafka-native-source.yaml Теперь мы можем отправлять сообщения в || knative-topic || и они будут автоматически перенаправляться в нашу службу Knative под названием || knative-hello-world. Обратите внимание, что || my-kafka || – это название службы Kubernetes. Очень ленивый способ отправлять сообщения в || knative-topic || mkubectl запустить kafka-producer -ti/kafka: 0.14.0-кафка-2.3.0 — bin/kafka-console-producer.sh –broker-list my-kafka:9092 –topic {Который отправит сообщение Kafka, которое будет преобразовано в облачное событие и отправлено в наше облако HTTP Даже в реальном проекте на самом деле не имеет значения, как вы его создаете, но если вам действительно нравится подход с поздней привязкой, вы также можете использовать его в своих приложениях Spring Boot, используя потоки Spring Cloud, которые предоставляют вам общий API для разных поставщиков обмена сообщениями. Одним из вариантов было бы просто воспользоваться API-интерфейсами Kafka Java и заставить ваше приложение записывать сообщения в предыдущую тему Kafka. электронное сообщение Кафки. t потребитель ( || познавательный-привет-мир || Познавательный сервис). “msg”: “Это тест!”} Затем введите сообщение в приглашении: knative-topic может использовать клиент Kafka из контейнера Docker, например: это было создано путем установки Kafka с помощью Helm.

Теперь мы готовы создать наш источник Kafka с приемником, указывающим на наш || native-hello-world || Native Service: kafka-native-source.yaml Теперь мы можем отправлять сообщения в || knative-topic || и они будут автоматически перенаправляться в нашу службу Knative под названием || knative-hello-world. Обратите внимание, что || my-kafka || – это название службы Kubernetes. Очень ленивый способ отправлять сообщения в || knative-topic || mkubectl запустить kafka-producer -ti/kafka: 0.14.0-кафка-2.3.0 — bin/kafka-console-producer.sh –broker-list my-kafka:9092 –topic {Который отправит сообщение Kafka, которое будет преобразовано в облачное событие и отправлено в наше облако HTTP Даже в реальном проекте на самом деле не имеет значения, как вы создаете это, если мы хотим теперь создать приложение Spring Boot, которое может отправлять сообщения в тему Kafka, которую мы ранее определили, нам просто нужно использовать зависимости потоков Spring Cloud и связующее Kafka. Но если вам действительно нравится подход с поздней привязкой, вы также можете использовать его в своих приложениях Spring Boot, используя Spring Cloud Streams, который предоставляет вам общий API для разных поставщиков обмена сообщениями. Одним из вариантов было бы просто воспользоваться API-интерфейсами Kafka Java и заставить ваше приложение записывать сообщения в предыдущую тему Kafka. электронное сообщение Кафки. t потребитель ( || познавательный-привет-мир || Познавательный сервис). “msg”: “Это тест!”} Затем введите сообщение в приглашении: knative-topic может использовать клиент Kafka из контейнера Docker, например: это было создано путем установки Kafka с помощью Helm. Теперь мы готовы создать наш источник Kafka с приемником, указывающим на наш || native-hello-world || Native Service: kafka-native-source.yaml Теперь мы можем отправлять сообщения в || knative-topic || и они будут автоматически перенаправляться в нашу службу Knative под названием || knative-hello-world. Обратите внимание, что || my-kafka || – это название службы Kubernetes. Очень ленивый способ отправлять сообщения в || knative-topic || mkubectl запустить kafka-producer -ti/kafka: 0.14.0-кафка-2.3.0 — bin/kafka-console-producer.sh –broker-list my-kafka:9092 –topic {Который отправит сообщение Kafka, которое будет преобразовано в облачное событие и отправлено в наше облако HTTP Даже в реальном проекте, на самом деле не имеет значения, как вы его создаете, вы можете найти исходный код этого примера здесь: Если мы хотим сейчас создать приложение Spring Boot, которое может отправлять сообщения в тему Kafka, которую мы ранее определили, нам просто нужно использовать зависимости Spring Cloud Streams и Kafka Binder. Но если вам действительно нравится подход с поздней привязкой, вы также можете использовать его в своих приложениях Spring Boot, используя Spring Cloud Streams, который предоставляет вам общий API для разных поставщиков обмена сообщениями. Одним из вариантов было бы просто воспользоваться API-интерфейсами Kafka Java и заставить ваше приложение записывать сообщения в предыдущую тему Kafka. электронное сообщение Кафки. t потребитель ( || познавательный-привет-мир || Познавательный сервис). “msg”: “Это тест!”} Затем введите сообщение в приглашении: knative-topic может использовать клиент Kafka из контейнера Docker, например: это было создано путем установки Kafka с помощью Helm.


  
    org.springframework.cloud
    spring-cloud-stream
  
  
    org.springframework.cloud
    spring-cloud-stream-binder-kafka
  
...

И затем простое приложение, которое отправляет сообщения

простое приложение, которое отправляет сообщения

@SpringBootApplication
@EnableBinding(MyChannels.class)
@EnableScheduling
public class KafkaProducerApplication {

  @Autowired
  private MessageChannel myProducer;

  ...

  @Scheduled(fixedDelay = 3000)
  public void sendMessageEveryX() {
    System.out.println("> Sending a message...");
    myProducer.send(MessageBuilder.withPayload("{\"name\":\"salaboy : " + UUID.randomUUID().toString() + " \"}").build());
  }

}

Это простое приложение будет отправлять сообщение каждые 3 секунды, но где?

Это поздняя привязка в действии. Где и какой связующий (какая реализация обмена сообщениями) может быть определена позже. В этом случае мы можем сделать это, изменив файл applications.properties с помощью:

В этом случае мы можем сделать это, изменив файл applications.properties с помощью:

spring.cloud.stream.kafka.binder.brokers=my-kafka
spring.cloud.stream.kafka.binder.defaultBrokerPort=9092
spring.cloud.stream.bindings.myProducer.destination=knative-topic

Но поскольку мы работаем с Docker, мы можем легко сделать это и с переменными окружения. Это означает, что в нашем контейнере эти детали не будут жестко закодированы, и мы сможем повторно использовать один и тот же образ docker в разных средах с разными установками Kafka и разными темами.

Чтобы создать проект, вы можете запустить:

чистый пакет mvn

Вам нужно будет создать этот образ docker с помощью:

сборка докера -t/knative-spring-cloud-event-producer .

И затем вы можете определить свой собственный сервис:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: knative-spring-cloud-event-producer
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/minScale: "1"
    spec:
      containers:
        - image: salaboy/knative-spring-cloud-event-producer

Обратите внимание: наше приложение не ожидает никаких HTTP-запросов. По умолчанию встроенное автоматическое масштабирование будет уменьшать масштаб приложения в зависимости от трафика. Для этого конкретного сценария мы не хотим, чтобы наше приложение уменьшалось в масштабе, по этой причине мы используем аннотацию: автоматическое масштабирование.knative.dev/Минимальная шкала: “1”

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

kubectl apply -f service.yaml

Если вы зарегистрируете выходные данные модуля knative-hello-world, вы увидите, что каждые 3 секунды вы будете получать облачное событие.

журналы kubectl -f knative-привет, мир-

Вы можете попробовать удалить auto scaling.native.dev/minScale: "1" и посмотреть, как через 90 секунд ваш модуль уменьшится до нуля, так как трафик к вашему производителю событий не поступает.

Вот он, пример, в котором используется собственное обслуживание + Собственное событие + События HTTP Transport Cloud + Исходный код Kafka + Потоки Spring Cloud.

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

В будущих сообщениях в блоге я поделюсь некоторыми подробностями о том, как Native и Zeebe ( http://zeebe.io ) интеграция создается для предоставления таких функций, как:

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

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

Оригинал: “https://dev.to/salaboy/getting-started-with-knative-2020-994”

Взаимодействие с нашим новым собственным сервисом

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