Lawrence  Lesch

Lawrence Lesch

1660985760

Simple Liveness & Readiness Check Middleware for Openshift/kubernetes

Connect middleware that sets up generic liveness and readiness probes for OpenShift/Kubernetes

Example Usage:

const express = require('express');
const app = express();

const probe = require('kube-probe');

probe(app);

This will add 2 GET endpoints /api/health/liveness and /api/health/readiness that will return a 200 OK response. This module uses overload-protection to identify when a process may be overloaded, and will return HTTP 503 Service Unavailable if the service becomes too heavily loaded. Configuration of the protection-config module may be passed as options.protectionConfig.

See: davidmarkclements/overload-protection/

Parameters

app - an instance of a connect-based framework (e.g. express.js) - required

options - optional

options.readinessURL - string - url where the readiness probe is located

options.livenessURL - string - url where the livenessURL probe is located

options.readinessCallback - function - function to call when the readiness probe is triggered

options.livenessCallback - function - function to call when the liveness probe is triggered

options.bypassProtection - boolean - kube-probe will bypass protection (defaults to false)

options.protectionConfig - object - options passed direction to overload-protection

Environment Variables

  • KUBE_PROBE_BYPASS_PROTECTION - boolean - kube-probe will bypass protection

This module is deprecated.

Download Details:

Author: Nodeshift-archived
Source Code: https://github.com/nodeshift-archived/kube-probe 
License: Apache-2.0 license

#javascript #openshift #kubernetes 

Simple Liveness & Readiness Check Middleware for Openshift/kubernetes
Thierry  Perret

Thierry Perret

1658428920

Comment Démarrer Avec Le Registre De Service OpenShift

Red Hat OpenShift Service Registry est un service entièrement hébergé et géré qui fournit une API et un registre de schémas pour les microservices . OpenShift Service Registry permet aux équipes de développement de publier, de découvrir et de réutiliser facilement les API et les schémas.

Des définitions d'API et de schéma bien définies sont essentielles pour fournir des architectures de microservices et de streaming d'événements robustes. Les équipes de développement peuvent utiliser un registre pour gérer ces artefacts dans différents formats, notamment OpenAPI , AsyncAPI , Apache Avro , Protocol Buffers , etc. Les producteurs et consommateurs de données peuvent ensuite utiliser les artefacts pour valider et sérialiser ou désérialiser les données.

Cet article vous permet de démarrer avec OpenShift Service Registry. Vous allez créer une application Java basée sur Quarkus qui utilise le registre pour gérer les schémas des données envoyées via les rubriques d'un cluster Apache Kafka . Le didacticiel devrait prendre moins de 30 minutes et comprend les étapes suivantes :

  1. Créez un compte Red Hat Hybrid Cloud.
  2. Provisionnez une instance de registre de service OpenShift.
  3. Provisionnez une instance OpenShift Streams pour Apache Kafka.
  4. Créer des sujets Kafka.
  5. Créez un compte de service pour faciliter l'accès authentifié à vos instances Kafka et Service Registry.
  6. Créez et exécutez une application Java.

Remarque : Les schémas et les définitions d'API sont des métadonnées qui représentent un contrat entre des services découplés. Ils doivent donc être des versions détectables, documentées et attribuées pour suivre leur évolution dans le temps.

À propos du registre de service OpenShift

Red Hat OpenShift Service Registry est basé sur le projet open source Apicurio Registry . Il fournit une instance de registre de services hautement disponible, sécurisée et compatible avec l' API Confluent Schema Registry et l'API CNCF Schema Registry . OpenShift Service Registry est également un service compagnon idéal pour les applications qui utilisent Red Hat OpenShift Streams pour Apache Kafka et Red Hat OpenShift API Management .

Conditions préalables

Vous avez besoin d'un compte Red Hat Hybrid Cloud pour exécuter les exemples de cet article. Créez un compte gratuitement sur console.redhat.com . Vous avez également besoin des outils suivants dans votre environnement de développement :

  • Java 11 ou supérieur
  • Maven 3.8.1 ou supérieur
  • Gite
  • Votre IDE ou éditeur de texte préféré

Créer une instance de registre de service

Les organisations ou les particuliers disposant d'un compte Red Hat Hybrid Cloud ont droit à une instance d'essai de deux mois d'OpenShift Service Registry. Pour créer une instance :

  1. Connectez-vous à votre compte sur console.redhat.com .
  2. Dans l'interface utilisateur (UI), sélectionnez Services d'application dans le menu de gauche.
  3. Développez l' entrée Service Registry dans le menu latéral et cliquez sur le lien Service Registry Instances . Acceptez l'avertissement indiquant qu'il s'agit d'un service bêta.
  4. Cliquez sur le bouton Créer une instance de registre de services . Une boîte de dialogue modale s'affiche.
  5. Entrez un nom pour votre instance Service Registry et cliquez sur le bouton Créer .

Votre instance OpenShift Service Registry sera prête à être utilisée dans une minute ou deux. Une coche verte s'affiche dans la colonne État pour indiquer quand l'instance est prête, comme illustré à la figure 1.

Lorsqu'une coche verte et un état Prêt s'affichent dans l'interface utilisateur OpenShift Service Registry, l'instance Service Registry peut être ouverte.

Figure 1 : Une instance de registre de service répertoriée dans l'interface utilisateur d'OpenShift Service Registry.

 

Une fois que votre instance est prête, cliquez sur sa ligne dans le portail pour afficher les informations de connexion, comme illustré à la figure 2. Prenez note de la valeur de l' API Core Registry , car vous en aurez bientôt besoin.

Les informations de connexion à l'instance de registre de service affichées dans l'interface utilisateur.

Figure 2 : Les informations de connexion de l'instance Service Registry affichées dans l'interface utilisateur.

Intégration d'applications Java avec Service Registry

Les applications de producteur Kafka peuvent utiliser des sérialiseurs pour coder des messages conformes à un schéma d'événement spécifique. Les applications client Kafka peuvent ensuite utiliser des désérialiseurs pour valider que les messages ont été sérialisés à l'aide du schéma correct, basé sur un ID de schéma spécifique. Ce processus est illustré à la figure 3. Vous allez tester la sérialisation et la désérialisation à l'aide d'applications Java producteur et consommateur qui se connectent à Kafka.

Les producteurs et les consommateurs de Kafka obtiennent des schémas du registre de service OpenShift.

Figure 3 : Applications Kafka producteur et consommateur utilisant le registre de service OpenShift pour partager des schémas.

Provisionner une instance Kafka gérée et créer des sujets

Pour commencer, vous devrez créer une instance OpenShift Streams pour Apache Kafka et deux sujets : l'un nommé quote-requestset l'autre nommé quotes. Nous avons expliqué comment obtenir cet environnement d'exécution gratuitement dans cet article .

N'oubliez pas de prendre note de l'URL du serveur d'amorçage de votre instance Kafka. Vous aurez bientôt besoin de cette URL.

Créer un compte de service

Un compte de service est requis pour connecter les applications au registre de service OpenShift et aux flux OpenShift pour les instances Apache Kafka. Le compte de service fournit un ID client et un secret client que les applications utilisent pour s'authentifier auprès des services cloud.

Pour créer un compte de service :

  1. Visitez console.redhat.com/beta/application-services/service-accounts .
  2. Cliquez sur le bouton Créer un compte de service .
  3. Entrez un nom pour le compte de service.
  4. Cliquez sur le bouton Créer .
  5. L'ID client et le secret client seront affichés. Copiez-les dans un endroit sûr.
  6. Fermez la boîte de dialogue modale.

Déploiement de l'application Java producteur

À ce stade, vous avez :

  • Une instance de registre de service OpenShift
  • Une instance OpenShift Streams pour Apache Kafka
  • Un compte de service pour connecter les applications aux deux instances précédentes
  • Sujets Kafka pour contenir les messages publiés par un producteur

Il est maintenant temps de déployer une application de producteur qui publie des messages sur votre rubrique Kafka. Cette application utilise un schéma Avro pour coder les messages au format Avro. Il publie également ce schéma dans votre registre de service OpenShift. Les applications grand public peuvent récupérer le schéma à partir d'OpenShift Service Registry pour désérialiser et valider les enregistrements qu'elles consomment à partir de votre rubrique Kafka.

Le code source pour le producteur et le consommateur est disponible dans ce référentiel GitHub . Clonez-le dans votre environnement de développement :

$ git clone $REPOSITORY_URL rhosr-getting-started

Ouvrez le rhosr-getting-startedprojet à l'aide de votre IDE ou éditeur de texte préféré, puis ouvrez le producer/pom.xmlfichier. Ce fichier contient des dépendances typiques utilisées pour se connecter à Kafka et exposer les services REST. La quarkus-apicurio-registry-avrodépendance est utilisée pour générer des classes Java basées sur les définitions de schéma Avro. Il apporte également les dépendances nécessaires pour travailler avec le registre de services, telles que les sérialiseurs et désérialiseurs Kafka prenant en charge le registre de services.

Ensuite, ouvrez le producer/src/main/avro/quote.avscfichier. Ce fichier contient un schéma Avro défini à l'aide de JSON. Ce schéma peut être utilisé pour générer une Quote.javaclasse qui étend et implémente la classe et l'interface Avro nécessaires. La Quoteclasse est utilisée pour sérialiser les messages sortants vers le sujet Kafka sous-jacent, et par le quotescanal pour désérialiser les messages entrants. La classe générée se trouve dans le target/generated-sources/Quota.javafichier après avoir compilé l'application ou l'avoir exécutée en mode développement.

Enfin, examinez le producer/src/main/resource/application.propertiesdossier. Ce fichier configure l'application pour se connecter à une instance Kafka, enregistrer des schémas avec un registre et utiliser la sérialisation et la désérialisation Avro.

Exécutez l'application du producteur

Vous pouvez exécuter l'application producteur où vous le souhaitez, y compris sur un cluster OpenShift. Je vais vous montrer comment vous pouvez exécuter le producteur dans votre environnement de développement local.

Tout d'abord, définissez les variables d'environnement suivantes dans un shell. Remplacez le texte entre <> crochets angulaires par les valeurs que vous avez trouvées dans les sections précédentes :

# Used to authenticate against the registry and kafka cluster
export CLIENT_ID=<your-client-id>
export CLIENT_SECRET=<your-client-secret>

# Used to connect to and authenticate against the service registry
export OAUTH_SERVER_URL=https://sso.redhat.com/auth
export REGISTRY_URL=<core-service-registry-url>

# Used to connect to and authenticate against the kafka cluster
export BOOTSTRAP_SERVER=<kafka-bootstrap-url>
export OAUTH_TOKEN_ENDPOINT_URI=https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token

 

Une fois ces valeurs définies, vous pouvez démarrer l'application producteur dans le même shell à l'aide de la commande suivante :

$ mvn quarkus:dev -f ./producer/pom.xml -Dquarkus-profile=prod

L'application Quarkus est maintenant en cours d'exécution et a exposé un serveur HTTP sur http://localhost:8080/ . Utilisez la commande suivante pour envoyer une requête POST qui crée un devis et l'envoie au quote-requestssujet Kafka :

$ curl -X POST http://localhost:8080/quotes/request

Vous devriez recevoir une réponse au format JSON contenant une citation unique idet un fichier random price.

Afficher le schéma de devis dans Service Registry

Lorsque vous démarrez l'application du producteur et faites une demande au point de /quotes/requestterminaison, le producteur se prépare à envoyer des données à votre rubrique Kafka. Avant d'envoyer les données, le producteur vérifie que le schéma Quote Avro est disponible dans OpenShift Service Registry. Si le schéma Quote est introuvable, le producteur publie le schéma dans le registre. Le producteur sérialise ensuite les données sortantes à l'aide du schéma et inclut l'ID de schéma enregistré dans la valeur du message.

Une application consommateur en aval peut utiliser l'ID de schéma trouvé dans la charge utile du message pour extraire le schéma nécessaire du registre. L'application consommateur peut ensuite utiliser le schéma pour valider et désérialiser le message entrant.

Pour confirmer que le schéma Avro a été publié dans OpenShift Service Registry :

  1. Accédez à votre liste d' instances de registre de service OpenShift .
  2. Sélectionnez l'instance utilisée par votre application productrice.
  3. Sélectionnez l' onglet Artefacts .

Vous devriez voir le schéma Quote, comme illustré à la figure 4.

Le schéma Quote Avro est répertorié dans le registre de service OpenShift.

Figure 4 : Le schéma Quote Avro répertorié dans OpenShift Service Registry.

Sélectionnez le schéma de devis dans la liste et affichez l' onglet Contenu . Utilisez le bouton Format pour améliorer la lisibilité du JSON et confirmez qu'il correspond au Quote.avscfichier dans la base de code de l'application du producteur.

Consommer des messages dans Service Registry

Le référentiel que vous avez cloné dans le cadre de cet exercice contient une application client. Cette application consommateur est configurée à l'aide des mêmes variables d'environnement que le producteur et lit les messages du quote-requestssujet. Étant donné que le producteur et le consommateur utilisent OpenShift Service Registry, le consommateur peut récupérer le schéma Avro nécessaire pour valider et désérialiser les demandes de devis entrantes.

Exécutez le producteur et le consommateur en même temps. Utilisez cURL pour ouvrir une connexion au point de terminaison des événements envoyés par le serveur (SSE) à http://localhost:8080/quotes , puis utilisez un autre client HTTP pour POST à ​​http://localhost:8080/quotes/request . Le consommateur doit correctement désérialiser et traiter les éléments de la quote-requestsrubrique et placer la citation traitée dans la quotesrubrique, après quoi le point de terminaison SSE doit afficher les éléments comme illustré à la figure 5.

Une commande cURL affiche les données désérialisées au format JSON reçues par le consommateur au point de terminaison SSE.

Figure 5 : Données désérialisées au format JSON reçues par le consommateur au point de terminaison SSE et affichées par une commande cURL.

Application des règles de compatibilité de schéma

OpenShift Service Registry prend en charge diverses règles de compatibilité de schéma pour empêcher la publication de modifications de schéma qui pourraient entraîner des incompatibilités avec les applications en aval (c'est-à-dire des modifications avec rupture). Vous pouvez en savoir plus sur les règles de compatibilité dans la documentation du service . Pour activer cette application :

  1. Ouvrez l'interface utilisateur du registre de service sur console.redhat.com/beta/application-services/service-registry .
  2. Sélectionnez votre instance et affichez le schéma de devis.
  3. Définissez la règle de validité sur complète et la règle de compatibilité sur arrière (voir la figure 6).
  4. Cliquez sur le bouton Télécharger une nouvelle version .
  5. Collez le schéma Avro suivant et cliquez sur Upload :
{
  "namespace": "org.acme.kafka.quarkus",
  "type": "record",
  "name": "Quote",
  "fields": [
    {
      "name": "id",
      "type": "string"
    },
    {
      "name": "price",
      "type": "int"
    },
    {
      "name": "notes",
      "type": "string"
    }
  ]
}

 

La figure 6 montre ces mises à jour dans la console.

La règle de compatibilité peut être définie dans l'interface utilisateur du registre du service OpenShift.

Figure 6 : Application des règles de compatibilité de schéma à l'aide de l'interface utilisateur OpenShift Service Registry.

Une erreur de contenu non valide doit s'afficher, car ce nouveau schéma a enfreint la règle de compatibilité descendante en ajoutant un nouveau champ obligatoire. Les nouveaux champs doivent être facultatifs si la rétrocompatibilité est activée. Comme l'indique le message d'erreur, de nouveaux schémas sont nécessaires pour fournir des schémas rétrocompatibles pour toute évolution future.

Conclusion

Félicitations ! Dans cet article, vous avez appris à :

  1. Utilisez le registre du service OpenShift.
  2. Utilisez les flux OpenShift pour Apache Kafka.
  3. Créez des schémas Avro.
  4. Intégrez des applications Java qui utilisent des schémas Avro avec les deux services.
  5. Gérez l'évolution du schéma et appliquez des règles pour empêcher les modifications avec rupture pour les consommateurs en aval.

Inscrivez-vous aux services décrits dans cet article et faites-nous part de votre expérience dans les commentaires.

Lien : https://developers.redhat.com/articles/2021/10/11/get-started-openshift-service-registry#consumer_messages_in_service_registry

#openshift

Comment Démarrer Avec Le Registre De Service OpenShift
田辺  亮介

田辺 亮介

1658421660

如何開始使用 OpenShift 服務註冊表

Red Hat OpenShift Service Registry 是一項完全託管和託管的服務,它為微服務提供 API 和模式註冊表。OpenShift Service Registry 使開發團隊可以輕鬆發布、發現和重用 API 和模式。

定義良好的 API 和模式定義對於提供強大的微服務和事件流架構至關重要。開發團隊可以使用註冊表以各種格式管理這些工件,包括OpenAPIAsyncAPIApache AvroProtocol Buffers等。然後,數據生產者和消費者可以使用工件來驗證和序列化或反序列化數據。

本文將幫助您開始使用 OpenShift Service Registry。您將創建一個基於QuarkusJava應用程序,該應用程序使用註冊表來管理通過Apache Kafka集群中的主題發送的數據的模式。本教程應花費不到 30 分鐘,包括以下步驟:

  1. 創建一個紅帽混合雲帳戶。
  2. 供應 OpenShift 服務註冊表實例。
  3. 為 Apache Kafka 實例供應 OpenShift Streams。
  4. 創建 Kafka 主題。
  5. 創建一個服務帳戶以促進對您的 Kafka 和 Service Registry 實例的身份驗證訪問。
  6. 構建並運行 Java 應用程序。

注意:模式和 API 定義是代表解耦服務之間契約的元數據,因此它們必須是可發現的、記錄的和分配的版本,以跟踪它們隨時間的演變。

關於 OpenShift 服務註冊表

Red Hat OpenShift Service Registry 基於開源Apicurio Registry 項目。它提供了一個高度可用的服務註冊實例,該實例安全且與Confluent Schema Registry APICNCF Schema Registry API兼容。對於使用Red Hat OpenShift Streams for Apache KafkaRed Hat OpenShift API Management的應用程序,OpenShift Service Registry 也是一項完美的配套服務。

先決條件

您需要一個紅帽混合雲帳戶來運行本文中的示例。在console.redhat.com免費創建一個帳戶。您的開發環境中還需要以下工具:

  • Java 11 或更高版本
  • Maven 3.8.1 或更高版本
  • 吉特
  • 您最喜歡的 IDE 或文本編輯器

創建服務註冊實例

擁有紅帽混合雲帳戶的組織或個人有權獲得為期兩個月的 OpenShift Service Registry 試用實例。創建實例:

  1. 在console.redhat.com上登錄您的帳戶。
  2. 在用戶界面 (UI) 中,從左側菜單中選擇應用程序服務。
  3. 展開側面菜單上的Service Registry條目,然後單擊Service Registry Instances鏈接。確認它是 Beta 服務的警告。
  4. 單擊創建服務註冊表實例按鈕。將顯示一個模態對話框。
  5. 輸入 Service Registry 實例的名稱,然後單擊Create按鈕。

您的 OpenShift Service Registry 實例將在一兩分鐘內準備好使用。狀態列中將顯示一個綠色複選標記,以指示實例何時準備就緒,如圖 1 所示。

當 OpenShift Service Registry UI 中顯示綠色複選標記和 Ready 狀態時,可以打開 Service Registry 實例。

圖 1:OpenShift Service Registry UI 中列出的 Service Registry 實例。

 

一旦您的實例準備就緒,請在門戶中單擊其行以查看連接信息,如圖 2 所示。記下Core Registry API值,因為您很快就會需要它。

UI 中顯示的服務註冊表實例連接信息。

圖 2:UI 中顯示的 Service Registry 實例連接信息。

將 Java 應用程序與 Service Registry 集成

Kafka 生產者應用程序可以使用序列化程序對符合特定事件模式的消息進行編碼。然後,Kafka 消費者應用程序可以使用反序列化器來驗證消息是否基於特定的模式 ID 使用正確的模式進行了序列化。這個過程如圖 3 所示。您將使用連接到 Kafka 的 Java 生產者和消費者應用程序來測試序列化和反序列化。

Kafka 中的生產者和消費者都從 OpenShift 服務註冊表中獲取模式。

圖 3:Kafka 生產者和消費者應用程序使用 OpenShift Service Registry 共享模式。

預配託管 Kafka 實例並創建主題

首先,您需要創建一個 OpenShift Streams for Apache Kafka 實例和兩個主題:一個名為quote-requests,另一個名為quotes. 我們已經在本文中解釋瞭如何免費獲得這個運行時環境。

請記住記下您的 Kafka 實例的引導服務器 URL。您很快就會需要這個 URL。

創建服務帳號

需要服務帳戶才能將應用程序連接到 OpenShift Service Registry 和 OpenShift Streams for Apache Kafka 實例。服務帳戶提供應用程序用來針對雲服務進行身份驗證的客戶端 ID 和客戶端密碼。

要創建服務帳戶:

  1. 訪問console.redhat.com/beta/application-services/service-accounts
  2. 單擊創建服務帳戶按鈕。
  3. 輸入服務帳戶的名稱。
  4. 單擊創建按鈕。
  5. 將顯示客戶端 ID 和客戶端密碼。將這些複製到安全的地方。
  6. 關閉模態對話框。

部署生產者 Java 應用程序

此時你有:

  • OpenShift 服務註冊實例
  • OpenShift Streams for Apache Kafka 實例
  • 用於將應用程序連接到前兩個實例的服務帳戶
  • Kafka 主題用於保存生產者發布的消息

現在,是時候部署一個將消息發佈到 Kafka 主題的生產者應用程序了。此應用程序利用 Avro 模式以 Avro 格式對消息進行編碼。它還會將此模式發佈到您的 OpenShift 服務註冊表。消費者應用程序可以從 OpenShift Service Registry 獲取模式,以反序列化和驗證它們從您的 Kafka 主題中使用的記錄。

生產者和消費者的源代碼都可以在這個GitHub 存儲庫中找到。將其克隆到您的開發環境中:

$ git clone $REPOSITORY_URL rhosr-getting-started

rhosr-getting-started使用您首選的 IDE 或文本編輯器打開項目,然後打開producer/pom.xml文件。此文件包含用於連接到 Kafka 和公開 REST 服務的典型依賴項。該quarkus-apicurio-registry-avro依賴項用於根據 Avro 模式定義生成 Java 類。它還引入了使用服務註冊表所需的依賴項,例如服務註冊表感知的 Kafka 序列化器和反序列化器。

接下來,打開producer/src/main/avro/quote.avsc文件。此文件包含使用 JSON 定義的 Avro 模式。此模式可用於生成Quote.java擴展和實現必要的 Avro 類和接口的類。該類Quote用於將傳出消息序列化到底層 Kafka 主題,並由quotes通道反序列化傳入消息。target/generated-sources/Quota.java編譯應用程序或在開發模式下運行後,可以在文件中找到生成的類。

最後,檢查producer/src/main/resource/application.properties文件。此文件將應用程序配置為連接到 Kafka 實例,向註冊表註冊模式,並使用 Avro 序列化和反序列化。

運行生產者應用程序

您可以在任何地方運行生產者應用程序,包括在 OpenShift 集群上。我將演示如何在本地開發環境中運行生產者。

首先,在 shell 中定義以下環境變量。將<>尖括號中的文本替換為您在前幾節中找到的值:

# Used to authenticate against the registry and kafka cluster
export CLIENT_ID=<your-client-id>
export CLIENT_SECRET=<your-client-secret>

# Used to connect to and authenticate against the service registry
export OAUTH_SERVER_URL=https://sso.redhat.com/auth
export REGISTRY_URL=<core-service-registry-url>

# Used to connect to and authenticate against the kafka cluster
export BOOTSTRAP_SERVER=<kafka-bootstrap-url>
export OAUTH_TOKEN_ENDPOINT_URI=https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token

 

定義這些值後,您可以使用以下命令在同一 shell 中啟動生產者應用程序:

$ mvn quarkus:dev -f ./producer/pom.xml -Dquarkus-profile=prod

Quarkus 應用程序現在正在運行,並在http://localhost:8080/上公開了一個 HTTP 服務器。使用以下命令發送一個 POST 請求,該請求創建一個報價並將其發送到quote-requestsKafka 主題:

$ curl -X POST http://localhost:8080/quotes/request

您應該收到 JSON 格式的響應,其中包含唯一的報價id和 random price

在 Service Registry 中查看報價模式

當您啟動生產者應用程序並向/quotes/request端點發出請求時,生產者準備好將數據發送到您的 Kafka 主題。在發送數據之前,生產者檢查 Quote Avro 模式在 OpenShift Service Registry 中是否可用。如果未找到 Quote 模式,則生產者將模式發佈到註冊表。然後,生產者使用模式序列化傳出數據,並將註冊的模式 ID 包含在消息值中。

下游消費者應用程序可以使用在消息負載中找到的模式 ID 從註冊表中獲取必要的模式。消費者應用程序然後可以使用模式來驗證和反序列化傳入的消息。

要確認 Avro 模式已發佈到 OpenShift Service Registry:

  1. 轉到您的OpenShift Service Registry Instances列表。
  2. 選擇您的生產者應用程序使用的實例。
  3. 選擇工件選項卡。

您應該看到 Quote 模式,如圖 4 所示。

Quote Avro 模式列在 OpenShift 服務註冊表中。

圖 4:OpenShift 服務註冊表中列出的 Quote Avro 模式。

在列表中選擇 Quote 模式並查看Content選項卡。使用Format按鈕提高 JSON 的易讀性,並確認它與Quote.avsc生產者應用程序代碼庫中的文件匹配。

在 Service Registry 中使用消息

您在本練習中克隆的存儲庫包含一個使用者應用程序。此消費者應用程序使用與生產者相同的環境變量進行配置,並從quote-requests主題中讀取消息。因為生產者和消費者使用 OpenShift 服務註冊表,所以消費者可以獲取必要的 Avro 模式來驗證和反序列化傳入的報價請求。

同時運行生產者和消費者。使用 cURL 在http://localhost:8080/quotes打開與服務器發送事件 (SSE) 端點的連接,然後使用另一個 HTTP 客戶端 POST 到http://localhost:8080/quotes/request。消費者應正確反序列化和處理quote-requests主題中的項目,並將處理後的報價放入quotes主題中,之後 SSE 端點應顯示項目,如圖 5 所示。

cURL 命令顯示消費者在 SSE 端點收到的反序列化的 JSON 格式數據。

圖 5:消費者在 SSE 端點接收並由 cURL 命令顯示的反序列化 JSON 格式數據。

強制執行架構兼容性規則

OpenShift Service Registry 支持各種模式兼容性規則,以防止發布可能導致與下游應用程序不兼容的模式更改(即破壞性更改)。您可以在服務文檔中閱讀有關兼容性規則的更多信息。要啟用此強制執行:

  1. 在console.redhat.com/beta/application-services/service-registry打開 Service Registry UI 。
  2. 選擇您的實例並查看報價架構。
  3. Validity Rule設置為Full,將Compatibility Rule設置為Backward(參見圖 6)。
  4. 單擊上傳新版本按鈕。
  5. 粘貼以下 Avro 架構並單擊Upload
{
  "namespace": "org.acme.kafka.quarkus",
  "type": "record",
  "name": "Quote",
  "fields": [
    {
      "name": "id",
      "type": "string"
    },
    {
      "name": "price",
      "type": "int"
    },
    {
      "name": "notes",
      "type": "string"
    }
  ]
}

 

圖 6 在控制台中顯示了這些更新。

可以在 OpenShift Service Registry UI 中設置兼容性規則。

圖 6:使用 OpenShift Service Registry UI 實施模式兼容性規則。

應顯示 Invalid Content 錯誤,因為此新模式通過添加新的必填字段違反了向後兼容性規則如果啟用了向後兼容性,新字段必須是可選的。如錯誤消息所示,需要新模式來為所有未來的演進提供向後兼容的模式。

結論

恭喜——在本文中,您學會瞭如何:

  1. 使用 OpenShift 服務註冊表。
  2. 將 OpenShift Streams 用於 Apache Kafka。
  3. 創建 Avro 模式。
  4. 將使用 Avro 模式的 Java 應用程序與這兩種服務集成。
  5. 管理模式演變並應用規則以防止下游消費者的破壞性更改。

註冊本文中描述的服務,並在評論中告訴我們您的體驗。

鏈接:https ://developers.redhat.com/articles/2021/10/11/get-started-openshift-service-registry#sumption_messages_in_service_registry

#openshift

如何開始使用 OpenShift 服務註冊表

Как начать работу с OpenShift Service Registry

Red Hat OpenShift Service Registry — это полностью размещенная и управляемая служба, предоставляющая API и реестр схем для микрослужб . OpenShift Service Registry позволяет командам разработчиков легко публиковать, обнаруживать и повторно использовать API и схемы.

Четко определенные определения API и схемы необходимы для предоставления надежных микросервисов и архитектур потоковой передачи событий. Команды разработчиков могут использовать реестр для управления этими артефактами в различных форматах, включая OpenAPI , AsyncAPI , Apache Avro , Protocol Buffers и другие. Затем производители и потребители данных могут использовать артефакты для проверки и сериализации или десериализации данных.

Эта статья поможет вам начать работу с OpenShift Service Registry. Вы создадите Java -приложение на основе Quarkus , которое использует реестр для управления схемами данных, отправляемых через разделы в кластере Apache Kafka . Учебное пособие должно занять менее 30 минут и включать следующие шаги:

  1. Создайте учетную запись Red Hat Hybrid Cloud.
  2. Подготовьте экземпляр OpenShift Service Registry.
  3. Подготовьте экземпляр OpenShift Streams для Apache Kafka.
  4. Создавайте темы Кафки.
  5. Создайте учетную запись службы, чтобы упростить доступ с проверкой подлинности к вашим экземплярам Kafka и Service Registry.
  6. Создайте и запустите приложение Java.

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

О сервисном реестре OpenShift

Red Hat OpenShift Service Registry основан на проекте Apicurio Registry с открытым исходным кодом . Он предоставляет высокодоступный экземпляр реестра служб, который является безопасным и совместимым как с API Confluent Schema Registry, так и с API CNCF Schema Registry . OpenShift Service Registry также является идеальным сопутствующим сервисом для приложений, использующих Red Hat OpenShift Streams для Apache Kafka и Red Hat OpenShift API Management .

Предпосылки

Для запуска примеров из этой статьи вам потребуется учетная запись Red Hat Hybrid Cloud. Создайте бесплатную учетную запись на console.redhat.com . Вам также потребуются следующие инструменты в вашей среде разработки:

  • Ява 11 или выше
  • Maven 3.8.1 или выше
  • Гит
  • Ваша любимая IDE или текстовый редактор

Создание экземпляра реестра служб

Организации или частные лица с учетной записью Red Hat Hybrid Cloud имеют право на двухмесячную пробную версию OpenShift Service Registry. Чтобы создать экземпляр:

  1. Войдите в свою учетную запись на console.redhat.com .
  2. В пользовательском интерфейсе выберите Службы приложений в меню слева.
  3. Разверните запись Service Registry в боковом меню и щелкните ссылку Service Registry Instances . Подтвердите предупреждение о том, что это бета-версия службы.
  4. Нажмите кнопку « Создать экземпляр реестра служб» . Появится модальное диалоговое окно.
  5. Введите имя для своего экземпляра Service Registry и нажмите кнопку « Создать » .

Ваш экземпляр OpenShift Service Registry будет готов к использованию через минуту или две. Зеленая галочка будет отображаться в столбце « Статус », чтобы указать, когда экземпляр будет готов, как показано на рис. 1.

Когда в пользовательском интерфейсе OpenShift Service Registry отображается зеленая галочка и статус «Готово», можно открыть экземпляр Service Registry.

Рис. 1. Экземпляр Service Registry, указанный в пользовательском интерфейсе OpenShift Service Registry.

 

Когда ваш экземпляр будет готов, щелкните его строку на портале, чтобы просмотреть информацию о подключении, как показано на рис. 2. Обратите внимание на значение Core Registry API , так как оно вам скоро понадобится.

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

Рис. 2. Информация о соединении экземпляра Service Registry, отображаемая в пользовательском интерфейсе.

Интеграция Java-приложений с Service Registry

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

Как производители, так и потребители в Kafka получают схемы из реестра служб OpenShift.

Рис. 3. Приложения-производители и потребители Kafka, использующие реестр служб OpenShift для совместного использования схем.

Подготовьте управляемый экземпляр Kafka и создайте темы

Для начала вам потребуется создать экземпляр OpenShift Streams для Apache Kafka и две темы: одну с именем quote-requestsи другую с именем quotes. В этой статье мы объяснили, как получить эту среду выполнения бесплатно .

Не забудьте записать URL-адрес сервера начальной загрузки вашего экземпляра Kafka. Вам скоро понадобится этот URL.

Создать учетную запись службы

Учетная запись службы требуется для подключения приложений к OpenShift Service Registry и OpenShift Streams для экземпляров Apache Kafka. Учетная запись службы предоставляет идентификатор клиента и секрет клиента, которые приложения используют для аутентификации в облачных службах.

Чтобы создать учетную запись службы:

  1. Посетите console.redhat.com/beta/application-services/service-accounts .
  2. Нажмите кнопку Создать учетную запись службы.
  3. Введите имя учетной записи службы.
  4. Нажмите кнопку Создать .
  5. Будут отображены идентификатор клиента и секрет клиента. Скопируйте их в безопасное место.
  6. Закройте модальный диалог.

Развертывание Java-приложения производителя

На данный момент у вас есть:

  • Экземпляр реестра службы OpenShift
  • Экземпляр OpenShift Streams для Apache Kafka
  • Учетная запись службы для подключения приложений к предыдущим двум экземплярам.
  • Темы Kafka для хранения сообщений, опубликованных производителем

Теперь пришло время развернуть приложение производителя, которое публикует сообщения в вашей теме Kafka. Это приложение использует схему Avro для кодирования сообщений в формате Avro. Он также публикует эту схему в реестре OpenShift Service Registry. Приложения-потребители могут получать схему из реестра службы OpenShift для десериализации и проверки записей, которые они используют, из вашей темы Kafka.

Исходный код как производителя, так и потребителя доступен в этом репозитории GitHub . Клонируйте его в свою среду разработки:

$ git clone $REPOSITORY_URL rhosr-getting-started

Откройте rhosr-getting-startedпроект с помощью предпочитаемой вами IDE или текстового редактора и откройте producer/pom.xmlфайл. Этот файл содержит типичные зависимости, которые используются для подключения к Kafka и предоставления служб REST. Зависимость quarkus-apicurio-registry-avroиспользуется для создания классов Java на основе определений схемы Avro. Он также включает зависимости, необходимые для работы с реестром служб, такие как сериализаторы и десериализаторы Kafka, поддерживающие реестр служб.

Далее откройте producer/src/main/avro/quote.avscфайл. Этот файл содержит схему Avro, определенную с помощью JSON. Эту схему можно использовать для создания Quote.javaкласса, который расширяет и реализует необходимый класс и интерфейс Avro. Класс Quoteиспользуется для сериализации исходящих сообщений в базовую тему Kafka, а по quotesканалу — для десериализации входящих сообщений. Сгенерированный класс можно найти в target/generated-sources/Quota.javaфайле после компиляции приложения или запуска его в режиме разработки.

Наконец, проверьте producer/src/main/resource/application.propertiesфайл. Этот файл настраивает приложение для подключения к экземпляру Kafka, регистрации схем в реестре и использования сериализации и десериализации Avro.

Запустите приложение производителя

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

Сначала определите следующие переменные среды в оболочке. Замените текст в угловых скобках <> значениями, которые вы нашли в предыдущих разделах:

# Used to authenticate against the registry and kafka cluster
export CLIENT_ID=<your-client-id>
export CLIENT_SECRET=<your-client-secret>

# Used to connect to and authenticate against the service registry
export OAUTH_SERVER_URL=https://sso.redhat.com/auth
export REGISTRY_URL=<core-service-registry-url>

# Used to connect to and authenticate against the kafka cluster
export BOOTSTRAP_SERVER=<kafka-bootstrap-url>
export OAUTH_TOKEN_ENDPOINT_URI=https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token

 

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

$ mvn quarkus:dev -f ./producer/pom.xml -Dquarkus-profile=prod

Приложение Quarkus запущено и открыло HTTP-сервер по адресу http://localhost:8080/ . Используйте следующую команду, чтобы отправить запрос POST, который создает цитату и отправляет ее в quote-requestsтему Kafka:

$ curl -X POST http://localhost:8080/quotes/request

Вы должны получить ответ в формате JSON, содержащий уникальную цитату idи случайный price.

Просмотрите схему Quote в Service Registry.

Когда вы запускаете приложение производителя и делаете запрос к /quotes/requestконечной точке, производитель готов отправить данные в вашу тему Kafka. Перед отправкой данных производитель проверяет, доступна ли схема Quote Avro в реестре службы OpenShift. Если схема Quote не найдена, производитель публикует схему в реестре. Затем производитель сериализует исходящие данные, используя схему, и включает зарегистрированный идентификатор схемы в значение сообщения.

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

Чтобы подтвердить, что схема Avro была опубликована в реестре OpenShift Service Registry:

  1. Перейдите к списку экземпляров реестра службы OpenShift .
  2. Выберите экземпляр, используемый вашим приложением-производителем.
  3. Выберите вкладку Артефакты .

Вы должны увидеть схему Quote, как показано на рисунке 4.

Схема Quote Avro указана в реестре служб OpenShift.

Рис. 4. Схема Quote Avro, указанная в реестре OpenShift Service Registry.

Выберите схему Quote в списке и просмотрите вкладку Content . Используйте кнопку « Формат» , чтобы улучшить разборчивость JSON, и убедитесь, что он соответствует Quote.avscфайлу в кодовой базе приложения-производителя.

Использование сообщений в Service Registry

Репозиторий, который вы клонировали в рамках этого упражнения, содержит потребительское приложение. Это приложение-потребитель настраивается с использованием тех же переменных среды, что и производитель, и считывает сообщения из quote-requestsраздела. Поскольку производитель и потребитель используют OpenShift Service Registry, потребитель может получить необходимую схему Avro для проверки и десериализации входящих запросов котировок.

Запустите производителя и потребителя одновременно. Используйте cURL, чтобы открыть соединение с конечной точкой отправленных сервером событий (SSE) по адресу http://localhost:8080/quotes , а затем используйте другой HTTP-клиент для POST на http://localhost:8080/quotes/request . Потребитель должен правильно десериализовать и обработать элементы из quote-requestsтемы и поместить обработанную цитату в quotesтему, после чего конечная точка SSE должна отобразить элементы, как показано на рисунке 5.

Команда cURL отображает десериализованные данные в формате JSON, полученные потребителем в конечной точке SSE.

Рис. 5. Десериализованные данные в формате JSON, полученные потребителем в конечной точке SSE и отображенные с помощью команды cURL.

Применение правил совместимости схем

OpenShift Service Registry поддерживает различные правила совместимости схем, чтобы предотвратить публикацию изменений схемы, которые могут привести к несовместимости с нижестоящими приложениями (то есть к нарушению изменений). Подробнее о правилах совместимости можно прочитать в документации сервиса . Чтобы включить это принудительное выполнение:

  1. Откройте пользовательский интерфейс Service Registry по адресу console.redhat.com/beta/application-services/service-registry .
  2. Выберите свой экземпляр и просмотрите схему Quote.
  3. Установите для правила проверки значение Full , а для правила совместимости — значение Backward (см. рис. 6).
  4. Нажмите кнопку Загрузить новую версию .
  5. Вставьте следующую схему Avro и нажмите « Загрузить» :
{
  "namespace": "org.acme.kafka.quarkus",
  "type": "record",
  "name": "Quote",
  "fields": [
    {
      "name": "id",
      "type": "string"
    },
    {
      "name": "price",
      "type": "int"
    },
    {
      "name": "notes",
      "type": "string"
    }
  ]
}

 

На рис. 6 показаны эти обновления в консоли.

Правило совместимости можно установить в пользовательском интерфейсе OpenShift Service Registry.

Рисунок 6: Применение правил совместимости схем с помощью пользовательского интерфейса OpenShift Service Registry.

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

Вывод

Поздравляем! Из этой статьи вы узнали, как:

  1. Используйте реестр службы OpenShift.
  2. Используйте потоки OpenShift для Apache Kafka.
  3. Создайте схемы Avro.
  4. Интегрируйте приложения Java, использующие схемы Avro, с обеими службами.
  5. Управляйте развитием схемы и применяйте правила, чтобы предотвратить критические изменения для нижестоящих потребителей.

Подпишитесь на услуги, описанные в этой статье, и расскажите нам о своем опыте в комментариях.

Ссылка: https://developers.redhat.com/articles/2021/10/11/get-started-openshift-service-registry#using_messages_in_service_registry

#openshift

Как начать работу с OpenShift Service Registry
Hong  Nhung

Hong Nhung

1658392721

Cách Bắt đầu Với OpenShift Service Registry

Red Hat OpenShift Service Registry là một dịch vụ được lưu trữ và quản lý đầy đủ, cung cấp đăng ký API và lược đồ cho các dịch vụ nhỏ . OpenShift Service Registry giúp các nhóm phát triển dễ dàng xuất bản, khám phá và sử dụng lại các API và lược đồ.

Các định nghĩa về API và lược đồ được xác định rõ ràng là điều cần thiết để cung cấp các kiến ​​trúc truyền trực tuyến sự kiện và dịch vụ vi mô mạnh mẽ. Các nhóm phát triển có thể sử dụng sổ đăng ký để quản lý các tạo tác này ở nhiều định dạng khác nhau, bao gồm OpenAPI , AsyncAPI , Apache Avro , Bộ đệm giao thức , v.v. Sau đó, nhà sản xuất và người tiêu dùng dữ liệu có thể sử dụng các tạo tác để xác thực và tuần tự hóa hoặc giải mã hóa dữ liệu.

Bài viết này giúp bạn bắt đầu với OpenShift Service Registry. Bạn sẽ tạo một ứng dụng Java dựa trên Quarkus sử dụng sổ đăng ký để quản lý các lược đồ cho dữ liệu được gửi qua các chủ đề trong một cụm Apache Kafka . Hướng dẫn này sẽ mất chưa đến 30 phút và bao gồm các bước sau:

  1. Tạo tài khoản Red Hat Hybrid Cloud.
  2. Cung cấp một phiên bản Đăng ký Dịch vụ OpenShift.
  3. Cung cấp OpenShift Streams cho phiên bản Apache Kafka.
  4. Tạo chủ đề Kafka.
  5. Tạo một tài khoản dịch vụ để tạo điều kiện cho việc truy cập đã xác thực vào các phiên bản Kafka và Service Registry của bạn.
  6. Xây dựng và chạy một ứng dụng Java.

Lưu ý : Các lược đồ và định nghĩa API là siêu dữ liệu đại diện cho một hợp đồng giữa các dịch vụ được phân tách, vì vậy chúng phải được phát hiện, ghi lại và các phiên bản được chỉ định để theo dõi sự phát triển của chúng theo thời gian.

Giới thiệu về OpenShift Service Registry

Red Hat OpenShift Service Registry dựa trên dự án Apicurio Registry mã nguồn mở . Nó cung cấp một phiên bản đăng ký dịch vụ có tính khả dụng cao, an toàn và tương thích với cả API đăng ký lược đồ hợp lưu và API đăng ký lược đồ CNCF . OpenShift Service Registry cũng là một dịch vụ đồng hành hoàn hảo cho các ứng dụng sử dụng Red Hat OpenShift Streams cho Apache KafkaRed Hat OpenShift API Management .

Điều kiện tiên quyết

Bạn cần có tài khoản Red Hat Hybrid Cloud để chạy các ví dụ trong bài viết này. Tạo một tài khoản miễn phí tại console.redhat.com . Bạn cũng cần các công cụ sau trong môi trường phát triển của mình:

  • Java 11 trở lên
  • Maven 3.8.1 trở lên
  • Git
  • IDE hoặc trình soạn thảo văn bản yêu thích của bạn

Tạo một phiên bản đăng ký dịch vụ

Các tổ chức hoặc cá nhân có tài khoản Red Hat Hybrid Cloud được quyền dùng thử hai tháng đối với OpenShift Service Registry. Để tạo một phiên bản:

  1. Đăng nhập vào tài khoản của bạn trên console.redhat.com .
  2. Trong giao diện người dùng (UI), chọn Dịch vụ ứng dụng từ menu bên trái.
  3. Mở rộng mục đăng ký dịch vụ trên menu bên và nhấp vào liên kết Phiên bản đăng ký dịch vụ . Thừa nhận cảnh báo rằng đó là một dịch vụ beta.
  4. Nhấp vào nút Tạo phiên bản đăng ký dịch vụ . Một hộp thoại phương thức sẽ được hiển thị.
  5. Nhập tên cho phiên bản Đăng ký dịch vụ của bạn và nhấp vào nút Tạo .

Phiên bản OpenShift Service Registry của bạn sẽ sẵn sàng để sử dụng sau một hoặc hai phút. Dấu kiểm màu xanh lục sẽ được hiển thị trong cột Trạng thái để cho biết khi nào phiên bản đã sẵn sàng, như thể hiện trong Hình 1.

Khi một dấu kiểm màu xanh lá cây và trạng thái Sẵn sàng được hiển thị trong giao diện người dùng Đăng ký Dịch vụ OpenShift, phiên bản Đăng ký Dịch vụ có thể được mở.

Hình 1: Một phiên bản đăng ký dịch vụ được liệt kê trong giao diện người dùng đăng ký dịch vụ OpenShift.

 

Khi phiên bản của bạn đã sẵn sàng, hãy nhấp vào hàng của nó trong cổng để xem thông tin kết nối, như thể hiện trong Hình 2. Hãy lưu ý đến giá trị Core Registry API vì bạn sẽ sớm cần đến nó.

Thông tin kết nối phiên bản đăng ký dịch vụ được hiển thị trong giao diện người dùng.

Hình 2: Thông tin kết nối phiên bản Service Registry được hiển thị trong giao diện người dùng.

Tích hợp các ứng dụng Java với Service Registry

Các ứng dụng của nhà sản xuất Kafka có thể sử dụng bộ tuần tự hóa để mã hóa các thông báo phù hợp với một lược đồ sự kiện cụ thể. Sau đó, các ứng dụng dành cho người tiêu dùng Kafka có thể sử dụng bộ giải mã để xác thực rằng các thông báo đã được tuần tự hóa bằng cách sử dụng lược đồ chính xác, dựa trên một ID lược đồ cụ thể. Quá trình này được minh họa trong Hình 3. Bạn sẽ kiểm tra tuần tự hóa và giải mã hóa bằng cách sử dụng các ứng dụng dành cho người tiêu dùng và nhà sản xuất Java kết nối với Kafka.

Cả nhà sản xuất và người tiêu dùng ở Kafka đều nhận được các lược đồ từ Cơ quan đăng ký dịch vụ OpenShift.

Hình 3: Các ứng dụng của nhà sản xuất và người tiêu dùng Kafka sử dụng OpenShift Service Registry để chia sẻ các lược đồ.

Cung cấp phiên bản Kafka được quản lý và tạo chủ đề

Để bắt đầu, bạn sẽ cần tạo một OpenShift Streams cho phiên bản Apache Kafka và hai chủ đề: một được đặt tên quote-requestsvà chủ đề còn lại được đặt tên quotes. Chúng tôi đã giải thích cách lấy môi trường thời gian chạy này miễn phí trong bài viết này .

Hãy nhớ lưu ý URL máy chủ bootstrap của phiên bản Kafka của bạn. Bạn sẽ cần URL này sớm.

Tạo tài khoản dịch vụ

Cần có tài khoản dịch vụ để kết nối các ứng dụng với OpenShift Service Registry và OpenShift Streams cho các phiên bản Apache Kafka. Tài khoản dịch vụ cung cấp ID khách hàng và bí mật khách hàng mà các ứng dụng sử dụng để xác thực với các dịch vụ đám mây.

Để tạo tài khoản dịch vụ:

  1. Truy cập console.redhat.com/beta/application-services/service-accounts .
  2. Nhấp vào nút Tạo tài khoản dịch vụ.
  3. Nhập tên cho tài khoản dịch vụ.
  4. Nhấp vào nút Tạo .
  5. ID khách hàng và bí mật khách hàng sẽ được hiển thị. Sao chép những thứ này xuống một nơi nào đó an toàn.
  6. Đóng hộp thoại phương thức.

Triển khai ứng dụng Java của nhà sản xuất

Tại thời điểm này, bạn có:

  • Một phiên bản OpenShift Service Registry
  • Một luồng OpenShift cho phiên bản Apache Kafka
  • Một tài khoản dịch vụ để kết nối các ứng dụng với hai phiên bản trước
  • Chủ đề Kafka để lưu giữ các thông điệp do nhà sản xuất xuất bản

Bây giờ, đã đến lúc triển khai ứng dụng nhà sản xuất đăng thông báo cho chủ đề Kafka của bạn. Ứng dụng này sử dụng lược đồ Avro để mã hóa thông báo ở định dạng Avro. Nó cũng xuất bản lược đồ này lên Cơ quan đăng ký dịch vụ OpenShift của bạn. Các ứng dụng dành cho người tiêu dùng có thể tìm nạp lược đồ từ Cơ quan đăng ký dịch vụ OpenShift để giải mã hóa và xác thực các bản ghi mà chúng sử dụng từ chủ đề Kafka của bạn.

Mã nguồn cho cả nhà sản xuất và người tiêu dùng đều có sẵn trong kho lưu trữ GitHub này . Sao chép nó vào môi trường phát triển của bạn:

$ git clone $REPOSITORY_URL rhosr-getting-started

Mở rhosr-getting-starteddự án bằng IDE hoặc trình soạn thảo văn bản ưa thích của bạn và mở producer/pom.xmltệp. Tệp này chứa các phụ thuộc điển hình được sử dụng để kết nối với Kafka và hiển thị các dịch vụ REST. Phần quarkus-apicurio-registry-avrophụ thuộc được sử dụng để tạo các lớp Java dựa trên các định nghĩa lược đồ Avro. Nó cũng mang lại các phụ thuộc cần thiết để hoạt động với sổ đăng ký dịch vụ, chẳng hạn như trình tuần tự Kafka nhận biết đăng ký dịch vụ và trình giải mã trên không.

Tiếp theo, mở producer/src/main/avro/quote.avsctệp. Tệp này chứa một lược đồ Avro được xác định bằng JSON. Lược đồ này có thể được sử dụng để tạo một Quote.javalớp mở rộng và triển khai lớp và giao diện Avro cần thiết. Lớp Quotenày được sử dụng để tuần tự hóa các tin nhắn đi theo chủ đề Kafka bên dưới và theo quoteskênh để giải mã hóa các tin nhắn đến. Lớp được tạo có thể được tìm thấy trong target/generated-sources/Quota.javatệp sau khi biên dịch ứng dụng hoặc chạy nó ở chế độ phát triển.

Cuối cùng, kiểm tra producer/src/main/resource/application.propertiestệp. Tệp này định cấu hình ứng dụng để kết nối với một phiên bản Kafka, đăng ký các lược đồ với một sổ đăng ký và sử dụng tuần tự hóa và giải mã của Avro.

Chạy ứng dụng nhà sản xuất

Bạn có thể chạy ứng dụng nhà sản xuất ở bất cứ đâu bạn muốn, kể cả trên một cụm OpenShift. Tôi sẽ trình bày cách bạn có thể điều hành nhà sản xuất trong môi trường phát triển địa phương của bạn.

Đầu tiên, xác định các biến môi trường sau trong một trình bao. Thay thế văn bản trong dấu ngoặc nhọn <> bằng các giá trị bạn đã tìm thấy trong các phần trước:

# Used to authenticate against the registry and kafka cluster
export CLIENT_ID=<your-client-id>
export CLIENT_SECRET=<your-client-secret>

# Used to connect to and authenticate against the service registry
export OAUTH_SERVER_URL=https://sso.redhat.com/auth
export REGISTRY_URL=<core-service-registry-url>

# Used to connect to and authenticate against the kafka cluster
export BOOTSTRAP_SERVER=<kafka-bootstrap-url>
export OAUTH_TOKEN_ENDPOINT_URI=https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token

 

Sau khi các giá trị này được xác định, bạn có thể khởi động ứng dụng nhà sản xuất trong cùng một trình bao bằng lệnh sau:

$ mvn quarkus:dev -f ./producer/pom.xml -Dquarkus-profile=prod

Ứng dụng Quarkus hiện đang chạy và đã hiển thị một máy chủ HTTP trên http: // localhost: 8080 / . Sử dụng lệnh sau để gửi một yêu cầu ĐĂNG sẽ tạo ra một trích dẫn và gửi nó đến quote-requestschủ đề Kafka:

$ curl -X POST http://localhost:8080/quotes/request

Bạn sẽ nhận được phản hồi ở định dạng JSON có chứa một trích dẫn duy nhất idvà ngẫu nhiên price.

Xem lược đồ Trích dẫn trong Sổ đăng ký Dịch vụ

Khi bạn khởi động ứng dụng nhà sản xuất và đưa ra yêu cầu tới /quotes/requestđiểm cuối, nhà sản xuất sẽ sẵn sàng gửi dữ liệu đến chủ đề Kafka của bạn. Trước khi gửi dữ liệu, nhà sản xuất kiểm tra xem lược đồ Trích dẫn Avro có sẵn trong OpenShift Service Registry hay không. Nếu không tìm thấy lược đồ Trích dẫn, nhà sản xuất sẽ xuất bản lược đồ lên sổ đăng ký. Sau đó, nhà sản xuất sắp xếp dữ liệu gửi đi bằng cách sử dụng lược đồ và bao gồm ID lược đồ đã đăng ký trong giá trị thông báo.

Ứng dụng dành cho người tiêu dùng hạ nguồn có thể sử dụng ID lược đồ được tìm thấy trong tải trọng thông báo để tìm nạp lược đồ cần thiết từ sổ đăng ký. Sau đó, ứng dụng dành cho người tiêu dùng có thể sử dụng lược đồ để xác thực và giải mã hóa thông báo đến.

Để xác nhận rằng lược đồ Avro đã được xuất bản lên Cơ quan đăng ký dịch vụ OpenShift:

  1. Truy cập danh sách Phiên bản đăng ký dịch vụ OpenShift của bạn .
  2. Chọn phiên bản được sử dụng bởi ứng dụng nhà sản xuất của bạn.
  3. Chọn tab Phần mềm .

Bạn sẽ thấy lược đồ Trích dẫn, như trong Hình 4.

Lược đồ Trích dẫn Avro được liệt kê trong Sổ đăng ký Dịch vụ OpenShift.

Hình 4: Lược đồ Trích dẫn Avro được liệt kê trong OpenShift Service Registry.

Chọn lược đồ Trích dẫn trong danh sách và xem tab Nội dung . Sử dụng nút Định dạng để cải thiện tính dễ đọc của JSON và xác nhận rằng nó khớp với Quote.avsctệp trong cơ sở mã ứng dụng của nhà sản xuất.

Sử dụng thông báo trong Sổ đăng ký dịch vụ

Kho lưu trữ bạn đã nhân bản như một phần của bài tập này chứa một ứng dụng dành cho người tiêu dùng. Ứng dụng dành cho người tiêu dùng này được định cấu hình bằng cách sử dụng các biến môi trường giống như trình sản xuất và đọc các thông báo từ quote-requestschủ đề. Bởi vì nhà sản xuất và người tiêu dùng sử dụng Đăng ký dịch vụ OpenShift, người tiêu dùng có thể tìm nạp lược đồ Avro cần thiết để xác thực và giải mã các yêu cầu báo giá đến.

Điều hành nhà sản xuất và người tiêu dùng cùng một lúc. Sử dụng cURL để mở kết nối đến điểm cuối của sự kiện do máy chủ gửi (SSE) tại http: // localhost: 8080 / quote , sau đó sử dụng HTTP client khác để POST đến http: // localhost: 8080 / quote / request . Người tiêu dùng nên giải mã và xử lý các mục từ quote-requestschủ đề một cách chính xác và đặt báo giá đã xử lý vào quoteschủ đề, sau đó điểm cuối SSE sẽ hiển thị các mục như trong Hình 5.

Lệnh cURL hiển thị dữ liệu định dạng JSON, được deserialized mà người tiêu dùng nhận được tại điểm cuối SSE.

Hình 5: Dữ liệu có định dạng JSON đã được giải mã hóa, được người tiêu dùng nhận tại điểm cuối SSE và được hiển thị bằng lệnh cURL.

Thực thi các quy tắc tương thích với lược đồ

OpenShift Service Registry hỗ trợ các quy tắc tương thích lược đồ khác nhau để ngăn chặn việc xuất bản các thay đổi lược đồ có thể dẫn đến sự không tương thích với các ứng dụng hạ lưu (tức là phá vỡ các thay đổi). Bạn có thể đọc thêm về các quy tắc tương thích trong tài liệu dịch vụ . Để kích hoạt việc thực thi này:

  1. Mở giao diện người dùng đăng ký dịch vụ tại console.redhat.com/beta/application-services/service-registry .
  2. Chọn trường hợp của bạn và xem lược đồ Trích dẫn.
  3. Đặt Quy tắc hợp lệ thành Đầy đủQuy tắc tương thích thành Lùi (xem Hình 6).
  4. Nhấp vào nút Tải lên phiên bản mới .
  5. Dán vào lược đồ Avro sau và nhấp vào Tải lên :
{
  "namespace": "org.acme.kafka.quarkus",
  "type": "record",
  "name": "Quote",
  "fields": [
    {
      "name": "id",
      "type": "string"
    },
    {
      "name": "price",
      "type": "int"
    },
    {
      "name": "notes",
      "type": "string"
    }
  ]
}

 

Hình 6 cho thấy các bản cập nhật này trong bảng điều khiển.

Quy tắc tương thích có thể được đặt trong giao diện người dùng đăng ký dịch vụ OpenShift.

Hình 6: Thực thi các quy tắc tương thích lược đồ bằng giao diện người dùng đăng ký dịch vụ OpenShift.

Lỗi Nội dung không hợp lệ sẽ được hiển thị, vì giản đồ mới này đã vi phạm quy tắc tương thích ngược bằng cách thêm trường bắt buộc mới. Các trường mới phải là tùy chọn nếu tính tương thích ngược được bật. Như thông báo lỗi đã chỉ ra, các lược đồ mới được yêu cầu cung cấp các lược đồ tương thích ngược cho tất cả các quá trình phát triển trong tương lai.

Sự kết luận

Xin chúc mừng — trong bài viết này, bạn đã học được cách:

  1. Sử dụng Đăng ký Dịch vụ OpenShift.
  2. Sử dụng OpenShift Streams cho Apache Kafka.
  3. Tạo lược đồ Avro.
  4. Tích hợp các ứng dụng Java sử dụng lược đồ Avro với cả hai dịch vụ.
  5. Quản lý sự phát triển của giản đồ và áp dụng các quy tắc để ngăn chặn những thay đổi vi phạm đối với người tiêu dùng hạ nguồn.

Đăng ký các dịch vụ được mô tả trong bài viết này và cho chúng tôi biết trải nghiệm của bạn trong các nhận xét.

Liên kết: https://developers.redhat.com/articles/2021/10/11/get-started-openshift-service-registry#consuming_messages_in_service_registry

#openshift

Cách Bắt đầu Với OpenShift Service Registry
Minh  Nguyet

Minh Nguyet

1658247660

Cách OpenShift Service Contexts Đơn Giản Hóa Kết Nối Máy Khách

Bản phát hành mới nhất của rhoas, giao diện dòng lệnh (CLI) cho các dịch vụ ứng dụng Red Hat OpenShift , bổ sung một tính năng mạnh mẽ và linh hoạt được gọi là ngữ cảnh dịch vụ giúp kết nối khách hàng với các phiên bản dịch vụ ứng dụng OpenShift của bạn dễ dàng hơn bao giờ hết. Bài viết này minh họa tính năng mới này và chỉ ra cách nó có thể đẩy nhanh quy trình phát triển của bạn cho các ứng dụng dựa trên luồng.

Bối cảnh dịch vụ tạo điều kiện thuận lợi cho các kết nối máy khách

Các dịch vụ ứng dụng Red Hat OpenShift, chẳng hạn như Red Hat OpenShift Streams cho Apache KafkaRed Hat OpenShift Service Registry , là các dịch vụ đám mây được quản lý cung cấp trải nghiệm hợp lý cho nhà phát triển để xây dựng, triển khai và mở rộng các ứng dụng thời gian thực trong môi trường đám mây lai.

Các dịch vụ ứng dụng OpenShift CLI là một giao diện dòng lệnh phong phú để quản lý các dịch vụ ứng dụng. Với tính năng ngữ cảnh dịch vụ mới, bạn có thể sử dụng CLI để xác định tập hợp các trường hợp dịch vụ cho các trường hợp sử dụng, dự án hoặc môi trường cụ thể, như được chỉ ra trong Hình 1. Sau khi bạn xác định ngữ cảnh, một lệnh duy nhất có thể tạo ra thông tin cấu hình kết nối cần thiết bởi các ứng dụng khách.

Bối cảnh đại diện cho một tập hợp các dịch vụ dành riêng cho một mục đích cụ thể.

Hình 1: Một ngữ cảnh đại diện cho một tập hợp các dịch vụ dành riêng cho một mục đích cụ thể.

Do đó, ngữ cảnh dịch vụ cho phép bạn chuyển đổi dễ dàng giữa các nhóm phiên bản dịch vụ đã xác định và tạo cấu hình kết nối nhanh chóng và đáng tin cậy cho các phiên bản đó. Quá trình này thể hiện một sự cải tiến đáng kể đối với các quy trình làm việc tốn thời gian và dễ xảy ra lỗi yêu cầu bạn tạo các tệp cấu hình riêng lẻ cho các phiên bản dịch vụ độc lập và ứng dụng bằng các ngôn ngữ khác nhau.

Bài viết này cho biết bối cảnh dịch vụ vượt trội ở đâu và tại sao chúng tôi rất vui được giới thiệu tính năng này.

Đầu tiên, chúng ta sẽ xem qua một ví dụ thực tế sử dụng ngữ cảnh dịch vụ để kết nối ứng dụng khách cục bộ với một số trường hợp trong dịch vụ ứng dụng OpenShift. Sau đó, chúng ta sẽ xem xét cách sử dụng ngữ cảnh với các ứng dụng dựa trên OpenShift và cách chia sẻ ngữ cảnh với các thành viên khác trong nhóm.

Kết nối ứng dụng Quarkus với các dịch vụ ứng dụng OpenShift

Ví dụ này sử dụng ngữ cảnh dịch vụ để kết nối một ứng dụng Quarkus mẫu với một số phiên bản Kafka và Service Registry trong các dịch vụ ứng dụng OpenShift. Ứng dụng Quarkus tạo ra một dòng trích dẫn (thực sự là các chuỗi ký tự được tạo ngẫu nhiên) và hiển thị chúng trên một trang web.

Đầu tiên, hãy tạo bối cảnh dịch vụ hoàn toàn mới:

$ rhoas context create --name quotes-dev

Bối cảnh bạn vừa tạo trở thành bối cảnh hiện tại . Bạn có thể tạo nhiều ngữ cảnh, đưa các dịch vụ khác nhau vào từng ngữ cảnh và đưa ra các ngữ cảnh cho các nhà phát triển khác nhau để họ có quyền truy cập vào các nhóm dịch vụ.

Tiếp theo, tạo một số phiên bản Kafka và Service Registry trong ngữ cảnh hiện tại:

$ rhoas kafka create --name example-kafka-instance --wait
$ rhoas service-registry create --name example-registry-instance

Các phiên bản Kafka và Service Registry mới được tự động thêm vào ngữ cảnh hiện tại. Bạn cũng có thể thêm các bản sao Kafka và Service Registry hiện có vào ngữ cảnh hiện tại bằng cách sử dụng các lệnh CLI set-kafkacontext set-registry CLI.

Bây giờ sao chép một ứng dụng Quarkus mẫu để chạy cục bộ:

$ git clone https://github.com/redhat-developer/app-services-guides.git
$ cd app-services-guides/code-examples/quarkus-service-registry-quickstart/

Ứng dụng Quarkus mẫu có hai thành phần: Một nhà sản xuất và một người tiêu dùng. Nhà sản xuất tạo một luồng thông báo trích dẫn cho một chủ đề Kafka. Thành phần người tiêu dùng sử dụng các thông báo này và hiển thị các chuỗi của chúng trên một trang web.

Ứng dụng Quarkus yêu cầu một chủ đề Kafka được gọi quotestrong phiên bản Kafka của bạn. Tạo chủ đề như sau:

$ rhoas kafka topic create --name quotes

Bạn đã tạo ngữ cảnh cho các phiên bản Kafka và Service Registry của mình, vì vậy bạn đã sẵn sàng tạo thông tin cấu hình cần thiết để kết nối ứng dụng Quarkus với các phiên bản này thông qua lệnh create -config  :

$ rhoas generate-config --type env --output-file ./producer/.env

Tất cả rhoascác lệnh được thực thi dựa trên tất cả các phiên bản dịch vụ trong ngữ cảnh hiện tại, vì vậy bạn không cần phải chỉ định rõ ràng bất kỳ phiên bản nào trong lệnh trước đó. Phạm vi tiếp cận rộng này là một đặc điểm quan trọng của bối cảnh dịch vụ. Tính năng này cung cấp cho bạn sự linh hoạt để chuyển đổi nhanh chóng và liền mạch giữa các tập hợp lớn các trường hợp dịch vụ và chạy các lệnh CLI đối với chúng.

Ứng dụng Quarkus yêu cầu thông tin cấu hình kết nối cho ngữ cảnh của bạn phải có sẵn cho cả nhà sản xuất và người tiêu dùng. Trước đó, bạn đã tạo cấu hình trong thư mục nhà sản xuất, vì vậy bạn có thể chỉ cần sao chép cùng một .envtệp vào thư mục tiêu dùng:

$ cp ./producer/.env ./consumer/.env 

Đối với ngữ cảnh mà bạn đã xác định, nội dung của .envtệp sẽ giống như sau:

## Generated by rhoas cli

## Kafka Configuration
KAFKA_HOST=test-insta-ca---q---mrrjobj---a.bf2.kafka.rhcloud.com:443

## Service Registry Configuration
SERVICE_REGISTRY_URL=https://bu98.serviceregistry.rhcloud.com/t/cc8a243a-feed-4a4c-9394-5a35ce83cca5
SERVICE_REGISTRY_CORE_PATH=/apis/registry/v2
SERVICE_REGISTRY_COMPAT_PATH=/apis/ccompat/v6

## Authentication Configuration
RHOAS_CLIENT_ID=srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd
RHOAS_CLIENT_SECRET=001a40b1-9a63-4c70-beda-3447b64a7783
RHOAS_OAUTH_TOKEN_URL=https://identity.api.openshift.com/auth/realms/rhoas/protocol/openid-connect/token

Lệnh generate-configđã tạo một tài khoản dịch vụ (dưới tên biến môi trường RHOAS_CLIENT_ID) để xác thực các ứng dụng khách với các phiên bản Kafka và Service Registry trong ngữ cảnh của bạn. Để cho phép tài khoản dịch vụ hoạt động với các phiên bản này, bạn cần cấp quyền truy cập tài khoản dịch vụ cho các phiên bản:

$ rhoas kafka acl grant-access --producer --consumer --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd --topic quotes --group all
$ rhoas service-registry role add --role manager --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd 

Trước đây, bạn đã .envcung cấp tệp cho cả nhà sản xuất và thành phần người tiêu dùng của ứng dụng Quarkus. Bây giờ sử dụng Apache Maven để chạy thành phần nhà sản xuất:

$ cd producer
$ mvn quarkus:dev

Thành producerphần bắt đầu tạo thông báo trích dẫn cho quoteschủ đề dành riêng trong cá thể Kafka.

Ứng dụng Quarkus cũng tạo ra một tạo tác lược đồ với ID quotes-valuetrong phiên bản Service Registry. Nhà sản xuất sử dụng cấu phần lược đồ để xác nhận rằng mỗi thông báo đại diện cho một câu trích dẫn tuân theo một cấu trúc đã xác định. Để xem nội dung của cấu phần lược đồ được tạo bởi ứng dụng Quarkus, hãy chạy lệnh sau:

$ rhoas service-registry artifact get --artifact-id quotes-value

Đầu ra là:

{
  "type": "record",
  "name": "Quote",
  "namespace": "org.acme.kafka.quarkus",
  "fields": [
    {
      "name": "id",
      "type": {
        "type": "string",
        "avro.java.string": "String"
      }
    },
    {
      "name": "price",
      "type": "int"
    }
  ]
}

Tiếp theo, với trình sản xuất vẫn đang chạy, hãy sử dụng Apache Maven để chạy thành phần người tiêu dùng:

$ cd consumer
$ mvn quarkus:dev

Thành phần người tiêu dùng sử dụng luồng báo giá và hiển thị chúng trên trang web địa phương của bạn tại http://localhost:8080/quotes.html. Thành phần người tiêu dùng cũng sử dụng cấu phần quotes-valuelược đồ để xác thực rằng các thông báo phù hợp với cấu trúc được xác định trong lược đồ.

Hình 2 cho thấy một ví dụ về kết quả hiển thị trên trang web.

Ví dụ này đã chỉ ra rằng, sau khi bạn xác định ngữ cảnh, việc kết nối ứng dụng khách của bạn với các dịch vụ ứng dụng OpenShift dễ dàng như tạo một tệp duy nhất cho thông tin kết nối và sao chép tệp này vào ứng dụng.

Trong phần cuối cùng của bài đăng blog này, chúng ta sẽ xem xét ngắn gọn hai trường hợp sử dụng khác: Sử dụng ngữ cảnh dịch vụ để kết nối các ứng dụng trong Red Hat OpenShift và chia sẻ bối cảnh dịch vụ với các thành viên khác trong nhóm.

Sử dụng ngữ cảnh dịch vụ để kết nối các ứng dụng dựa trên OpenShift

Trong ví dụ trước, bạn đã tạo cấu hình kết nối dưới dạng một tập hợp các biến môi trường, thuận tiện cho ứng dụng khách chạy cục bộ. Nhưng nếu bạn đang chạy một ứng dụng dựa trên vùng chứa trên OpenShift thì sao? Vâng, bối cảnh dịch vụ cũng làm cho điều đó trở nên dễ dàng. Trong trường hợp này, bạn có thể trực tiếp tạo thông tin cấu hình kết nối dưới dạng tệp bí mật OpenShift:

$ rhoas generate-config --type secret --output-file ./rhoas-services-secret.yaml

Khi bạn đã tạo một bí mật, bạn có thể lưu trữ nó một cách an toàn bằng các phương pháp như:

  • Một giải pháp quản lý bí mật như Hashicorp Vault
  • Trình cắm thêm bí mật
  • Mã hóa và đưa bí mật vào kho lưu trữ GitHub

Bạn có thể áp dụng bí mật cho dự án OpenShift bằng cách sử dụng lệnh như sau:

$ oc apply -f ./rhoas-services-secret.yaml

Khi bạn đã áp dụng bí mật cho dự án OpenShift của mình, bạn có thể tham khảo bí mật từ nhiều tài nguyên khác nhau, bao gồm các mẫu ứng dụng OpenShift, bản dựng Source-to-Image (S2I), biểu đồ Helm và cấu hình ràng buộc dịch vụ.

Chia sẻ bối cảnh dịch vụ

Để chia sẻ ngữ cảnh với các thành viên khác trong nhóm, bạn chỉ cần chia sẻ tệp cấu hình của ngữ cảnh. Ví dụ: bạn có thể đẩy tệp vào kho lưu trữ GitHub được chia sẻ như được mô tả trong phần này.

Đừng nhầm lẫn tệp cấu hình của ngữ cảnh với .envtệp của các biến môi trường mà bạn đã tạo cho thông tin kết nối trước đó trong bài viết. Thay vào đó, tệp ngữ cảnh liệt kê các trường hợp dịch vụ có trong ngữ cảnh. Tệp chứa JSON và được lưu trữ cục bộ trên máy tính của bạn. Để lấy đường dẫn đến tệp ngữ cảnh, hãy chạy lệnh sau:

$ rhoas context status

Khi bạn có đường dẫn đến tệp, bạn có thể sao chép nó vào một vị trí chẳng hạn như kho lưu trữ Git cục bộ. Một ví dụ cho Linux như sau:

$ cp <path-to-context-file> ./profiles.json

Để chia sẻ bối cảnh dịch vụ với các nhà phát triển khác, hãy cam kết và đẩy tệp đến một khu vực làm việc chung chẳng hạn như kho lưu trữ Git của nhóm. Thật an toàn khi đẩy các tệp ngữ cảnh ngay cả vào các kho lưu trữ công khai vì các tệp chỉ chứa các số nhận dạng cho các phiên bản dịch vụ.

Bây giờ, giả sử một thành viên khác trong nhóm muốn sử dụng ngữ cảnh được chia sẻ. Khi thành viên trong nhóm đó có tệp ngữ cảnh (ví dụ: họ đã tìm nạp nó từ kho lưu trữ được chia sẻ), họ phải xác định một biến môi trường có tên RHOAS_CONTEXTtrỏ đến tệp ngữ cảnh. Một ví dụ cho Linux như sau:

$ export RHOAS_CONTEXT=./profiles.json

Bối cảnh dịch vụ: Nhanh chóng, an toàn và có thể mở rộng

Bài viết này đã chỉ ra cách tính năng ngữ cảnh dịch vụ mới của CLI giúp đơn giản hóa đáng kể công việc kết nối các ứng dụng khách với tập hợp các trường hợp dịch vụ trong các dịch vụ ứng dụng Red Hat OpenShift. Tính năng mạnh mẽ và linh hoạt này tự động hóa công việc mà trước đây bạn đã dành cho các tác vụ cấu hình thủ công, dễ xảy ra lỗi và cho phép nhóm của bạn tập trung vào những gì nó làm tốt nhất: Phát triển các ứng dụng dựa trên luồng tuyệt vời.

Liên kết: https://developers.redhat.com/articles/2022/07/18/simplify-client-connection-configurations-service-contexts#sharing_service_contexts

#openshift #redhat 

Cách OpenShift Service Contexts Đơn Giản Hóa Kết Nối Máy Khách
Thierry  Perret

Thierry Perret

1658236800

Comment Les Contextes De Service OpenShift Les Connexions Client

La dernière version de rhoas, l'interface de ligne de commande (CLI) pour les services d'application Red Hat OpenShift , ajoute une fonction puissante et flexible appelée contextes de service qui facilite plus que jamais la connexion des clients à vos instances de services d'application OpenShift. Cet article illustre cette nouvelle fonctionnalité et montre comment elle peut accélérer vos workflows de développement pour les applications basées sur les flux.

Les contextes de service facilitent les connexions client

Les services d'application Red Hat OpenShift, tels que Red Hat OpenShift Streams pour Apache Kafka et Red Hat OpenShift Service Registry , sont des services cloud gérés qui offrent une expérience de développement rationalisée pour la création, le déploiement et la mise à l'échelle d'applications en temps réel dans des environnements de cloud hybride.

L'interface de ligne de commande des services d'application OpenShift est une interface de ligne de commande riche pour la gestion des services d'application. Avec la nouvelle fonctionnalité de contextes de service, vous pouvez utiliser la CLI pour définir des ensembles d'instances de service pour des cas d'utilisation, des projets ou des environnements spécifiques, comme indiqué dans la figure 1. Après avoir défini un contexte, une seule commande peut générer les informations de configuration de connexion requises par les applications clientes.

Un contexte représente un ensemble de services dédiés à un objectif particulier.

Figure 1 : Un contexte représente un ensemble de services dédiés à un objectif particulier.

Ainsi, les contextes de service vous permettent de basculer facilement entre des ensembles définis d'instances de service et de générer rapidement et de manière fiable des configurations de connexion pour ces instances. Ce processus représente une amélioration significative par rapport aux flux de travail chronophages et sujets aux erreurs qui vous obligent à créer des fichiers de configuration individuels pour les instances de service autonomes et les applications dans différentes langues.

Cet article montre où les contextes de service excellent et pourquoi nous sommes ravis de présenter cette fonctionnalité.

Tout d'abord, nous allons parcourir un exemple pratique qui utilise des contextes de service pour connecter une application cliente locale à certaines instances dans les services d'application OpenShift. Ensuite, nous verrons comment utiliser les contextes avec les applications basées sur OpenShift et comment partager des contextes avec d'autres membres de l'équipe.

Connecter une application Quarkus aux services d'application OpenShift

Cet exemple utilise des contextes de service pour connecter un exemple d'application Quarkus à certaines instances de Kafka et Service Registry dans les services d'application OpenShift. L'application Quarkus produit un flux de guillemets (en fait des chaînes de caractères générées aléatoirement) et les affiche sur une page Web.

Tout d'abord, créez un tout nouveau contexte de service :

$ rhoas context create --name quotes-dev

Le contexte que vous venez de créer devient le contexte courant . Vous pouvez créer plusieurs contextes, mettre différents services dans chacun d'eux et offrir des contextes à différents développeurs pour leur donner accès à des ensembles de services.

Ensuite, créez des instances Kafka et Service Registry dans le contexte actuel :

$ rhoas kafka create --name example-kafka-instance --wait
$ rhoas service-registry create --name example-registry-instance

Les nouvelles instances Kafka et Service Registry sont automatiquement ajoutées au contexte actuel. Vous pouvez également ajouter des instances Kafka et Service Registry existantes au contexte actuel à l'aide des commandes CLI context set-kafka et context set-registry .

Maintenant, clonez un exemple d'application Quarkus à exécuter localement :

$ git clone https://github.com/redhat-developer/app-services-guides.git
$ cd app-services-guides/code-examples/quarkus-service-registry-quickstart/

L'exemple d'application Quarkus comporte deux composants : un producteur et un consommateur. Le producteur génère un flux de messages de citation vers un sujet Kafka. Le composant consommateur consomme ces messages et affiche leurs chaînes sur une page Web.

L'application Quarkus nécessite une rubrique Kafka appelée quotesdans votre instance Kafka. Créez le sujet comme suit :

$ rhoas kafka topic create --name quotes

Vous avez déjà créé un contexte pour vos instances Kafka et Service Registry, vous êtes donc prêt à générer les informations de configuration requises pour connecter l'application Quarkus à ces instances via une commande generate-config :

$ rhoas generate-config --type env --output-file ./producer/.env

Toutes les rhoascommandes sont exécutées sur toutes les instances de service dans le contexte actuel, vous n'avez donc pas besoin de spécifier explicitement des instances dans la commande précédente. Cette large portée est une caractéristique importante des contextes de service. Cette fonctionnalité vous donne la possibilité de basculer rapidement et de manière transparente entre de grands ensembles d'instances de service et d'exécuter des commandes CLI sur celles-ci.

L'application Quarkus nécessite que les informations de configuration de connexion pour votre contexte soient disponibles à la fois pour le producteur et le consommateur. Vous avez précédemment généré la configuration dans le répertoire producteur, vous pouvez donc simplement copier le même .envfichier dans le répertoire consommateur :

$ cp ./producer/.env ./consumer/.env 

Pour le contexte que vous avez défini, le contenu du .envfichier doit ressembler à ceci :

## Generated by rhoas cli

## Kafka Configuration
KAFKA_HOST=test-insta-ca---q---mrrjobj---a.bf2.kafka.rhcloud.com:443

## Service Registry Configuration
SERVICE_REGISTRY_URL=https://bu98.serviceregistry.rhcloud.com/t/cc8a243a-feed-4a4c-9394-5a35ce83cca5
SERVICE_REGISTRY_CORE_PATH=/apis/registry/v2
SERVICE_REGISTRY_COMPAT_PATH=/apis/ccompat/v6

## Authentication Configuration
RHOAS_CLIENT_ID=srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd
RHOAS_CLIENT_SECRET=001a40b1-9a63-4c70-beda-3447b64a7783
RHOAS_OAUTH_TOKEN_URL=https://identity.api.openshift.com/auth/realms/rhoas/protocol/openid-connect/token

La generate-configcommande a créé un compte de service (sous le nom de la variable d'environnement RHOAS_CLIENT_ID) pour authentifier les applications clientes avec les instances Kafka et Service Registry dans votre contexte. Pour permettre au compte de service de fonctionner avec ces instances, vous devez accorder au compte de service l'accès aux instances :

$ rhoas kafka acl grant-access --producer --consumer --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd --topic quotes --group all
$ rhoas service-registry role add --role manager --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd 

Auparavant, vous avez mis le .envfichier à la disposition des composants producteur et consommateur de l'application Quarkus. Utilisez maintenant Apache Maven pour exécuter le composant producteur :

$ cd producer
$ mvn quarkus:dev

Le producercomposant commence à générer des messages de citation vers le quotessujet dédié dans l'instance Kafka.

L'application Quarkus a également créé un artefact de schéma avec un ID quotes-valuedans l'instance Service Registry. Le producteur utilise l'artefact de schéma pour valider que chaque message représentant un devis est conforme à une structure définie. Pour afficher le contenu de l'artefact de schéma créé par l'application Quarkus, exécutez la commande suivante :

$ rhoas service-registry artifact get --artifact-id quotes-value

La sortie est :

{
  "type": "record",
  "name": "Quote",
  "namespace": "org.acme.kafka.quarkus",
  "fields": [
    {
      "name": "id",
      "type": {
        "type": "string",
        "avro.java.string": "String"
      }
    },
    {
      "name": "price",
      "type": "int"
    }
  ]
}

Ensuite, avec le producteur toujours en cours d'exécution, utilisez Apache Maven pour exécuter le composant consommateur :

$ cd consumer
$ mvn quarkus:dev

Le composant consommateur consomme le flux de citations et les affiche sur votre page Web locale à l'adresse http://localhost:8080/quotes.html. Le composant consommateur utilise également l' quotes-valueartefact de schéma pour valider que les messages sont conformes à la structure définie dans le schéma.

La figure 2 montre un exemple de la sortie affichée sur la page Web.

Cet exemple a montré qu'après avoir défini un contexte, connecter votre application cliente aux services d'application OpenShift était aussi simple que de générer un seul fichier pour les informations de connexion et de copier ce fichier dans l'application.

Dans les dernières sections de ce billet de blog, nous examinerons brièvement deux autres cas d'utilisation : l'utilisation de contextes de service pour connecter des applications dans Red Hat OpenShift et le partage de contextes de service avec d'autres membres de l'équipe.

Utilisation de contextes de service pour connecter des applications basées sur OpenShift

Dans l'exemple précédent, vous avez généré une configuration de connexion sous la forme d'un ensemble de variables d'environnement, ce qui est pratique pour une application cliente exécutée localement. Mais que se passe-t-il si vous exécutez une application basée sur un conteneur sur OpenShift ? Eh bien, les contextes de service facilitent également la tâche. Dans cette situation, vous pouvez générer directement les informations de configuration de connexion sous forme de fichier secret OpenShift :

$ rhoas generate-config --type secret --output-file ./rhoas-services-secret.yaml

Lorsque vous avez généré un secret, vous pouvez le stocker en toute sécurité à l'aide de méthodes telles que :

  • Une solution de gestion des secrets telle que Hashicorp Vault
  • Le plug-in helm-secrets
  • Chiffrement et transmission du secret à un référentiel GitHub

Vous pouvez appliquer le secret à un projet OpenShift à l'aide d'une commande comme celle-ci :

$ oc apply -f ./rhoas-services-secret.yaml

Lorsque vous avez appliqué le secret à votre projet OpenShift, vous pouvez vous y référer à partir de diverses ressources, notamment les modèles d'application OpenShift, les builds Source-to-Image (S2I), les chartes Helm et les configurations de liaison de service.

Partage des contextes de service

Pour partager un contexte avec d'autres membres de l'équipe, il vous suffit de partager le fichier de configuration du contexte. Par exemple, vous pouvez transférer le fichier vers un référentiel GitHub partagé, comme décrit dans cette section.

Ne confondez pas le fichier de configuration du contexte avec le .envfichier de variables d'environnement que vous avez généré pour les informations de connexion plus haut dans l'article. Au lieu de cela, le fichier de contexte répertorie les instances de service qui se trouvent dans le contexte. Le fichier contient JSON et est stocké localement sur votre ordinateur. Pour obtenir le chemin d'accès au fichier de contexte, exécutez la commande suivante :

$ rhoas context status

Lorsque vous avez le chemin d'accès au fichier, vous pouvez le copier dans un emplacement tel qu'un référentiel Git local. Un exemple pour Linux suit :

$ cp <path-to-context-file> ./profiles.json

Pour partager le contexte de service avec d'autres développeurs, validez et transférez le fichier vers une zone de travail partagée telle que le référentiel Git de l'équipe. Il est sûr de pousser des fichiers de contexte même vers des référentiels publics car les fichiers ne contiennent que des identifiants pour les instances de service.

Supposons maintenant qu'un autre membre de l'équipe souhaite utiliser le contexte partagé. Lorsque ce membre de l'équipe dispose du fichier de contexte (il l'a récupéré à partir du référentiel partagé, par exemple), il doit définir une variable d'environnement appelée RHOAS_CONTEXTqui pointe vers le fichier de contexte. Un exemple pour Linux suit :

$ export RHOAS_CONTEXT=./profiles.json

Contextes de service : rapides, sûrs et évolutifs

Cet article a montré comment la nouvelle fonctionnalité de contextes de service de la CLI simplifie considérablement le travail de connexion des applications clientes à des ensembles d'instances de service dans les services d'application Red Hat OpenShift. Cette fonctionnalité puissante et flexible automatise le travail que vous consacriez auparavant aux tâches de configuration manuelles sujettes aux erreurs et permet à votre équipe de se concentrer sur ce qu'elle fait le mieux : développer d'excellentes applications basées sur les flux.

Lien : https://developers.redhat.com/articles/2022/07/18/simplify-client-connection-configurations-service-contexts#sharing_service_contexts

#openshift #redhat 

Comment Les Contextes De Service OpenShift Les Connexions Client

Как контексты службы OpenShift упрощают клиентские подключения

В последнем выпуске rhoasинтерфейса командной строки (CLI) для служб приложений Red Hat OpenShift добавлена ​​мощная и гибкая функция, называемая контекстами служб , которая упрощает подключение клиентов к вашим экземплярам служб приложений OpenShift. Эта статья иллюстрирует эту новую функцию и показывает, как она может ускорить рабочие процессы разработки потоковых приложений.

Контексты службы облегчают клиентские подключения

Сервисы приложений Red Hat OpenShift, такие как Red Hat OpenShift Streams для Apache Kafka и Red Hat OpenShift Service Registry , представляют собой управляемые облачные сервисы, которые упрощают разработку, развертывание и масштабирование приложений реального времени в гибридных облачных средах.

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

Контекст представляет собой набор сервисов, предназначенных для определенной цели.

Рисунок 1: Контекст представляет собой набор сервисов, предназначенных для определенной цели.

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

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

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

Подключите приложение Quarkus к службам приложений OpenShift.

В этом примере контексты службы используются для подключения примерного приложения Quarkus к некоторым экземплярам Kafka и Service Registry в службах приложений OpenShift. Приложение Quarkus создает поток цитат (на самом деле случайно сгенерированные строки символов) и отображает их на веб-странице.

Во-первых, создайте совершенно новый контекст службы:

$ rhoas context create --name quotes-dev

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

Затем создайте несколько экземпляров Kafka и Service Registry в текущем контексте:

$ rhoas kafka create --name example-kafka-instance --wait
$ rhoas service-registry create --name example-registry-instance

Новые экземпляры Kafka и Service Registry автоматически добавляются в текущий контекст. Вы также можете добавить существующие экземпляры Kafka и Service Registry в текущий контекст с помощью команд CLI context set-kafka и context set-registry .

Теперь клонируйте пример приложения Quarkus для локального запуска:

$ git clone https://github.com/redhat-developer/app-services-guides.git
$ cd app-services-guides/code-examples/quarkus-service-registry-quickstart/

Пример приложения Quarkus состоит из двух компонентов: производителя и потребителя. Производитель генерирует поток сообщений с цитатами в теме Kafka. Компонент-потребитель использует эти сообщения и отображает их строки на веб-странице.

Приложению Quarkus требуется тема Kafka, вызываемая quotesв вашем экземпляре Kafka. Создайте тему следующим образом:

$ rhoas kafka topic create --name quotes

Вы уже создали контекст для своих экземпляров Kafka и Service Registry, поэтому готовы сгенерировать информацию о конфигурации, необходимую для подключения приложения Quarkus к этим экземплярам, ​​с помощью команды generate-config  :

$ rhoas generate-config --type env --output-file ./producer/.env

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

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

$ cp ./producer/.env ./consumer/.env 

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

## Generated by rhoas cli

## Kafka Configuration
KAFKA_HOST=test-insta-ca---q---mrrjobj---a.bf2.kafka.rhcloud.com:443

## Service Registry Configuration
SERVICE_REGISTRY_URL=https://bu98.serviceregistry.rhcloud.com/t/cc8a243a-feed-4a4c-9394-5a35ce83cca5
SERVICE_REGISTRY_CORE_PATH=/apis/registry/v2
SERVICE_REGISTRY_COMPAT_PATH=/apis/ccompat/v6

## Authentication Configuration
RHOAS_CLIENT_ID=srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd
RHOAS_CLIENT_SECRET=001a40b1-9a63-4c70-beda-3447b64a7783
RHOAS_OAUTH_TOKEN_URL=https://identity.api.openshift.com/auth/realms/rhoas/protocol/openid-connect/token

Команда generate-configсоздала учетную запись службы (под именем переменной среды RHOAS_CLIENT_ID) для аутентификации клиентских приложений с помощью экземпляров Kafka и Service Registry в вашем контексте. Чтобы учетная запись службы могла работать с этими экземплярами, вам необходимо предоставить учетной записи службы доступ к экземплярам:

$ rhoas kafka acl grant-access --producer --consumer --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd --topic quotes --group all
$ rhoas service-registry role add --role manager --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd 

Ранее вы сделали .envфайл доступным как для компонентов-производителей, так и для компонентов-потребителей приложения Quarkus. Теперь используйте Apache Maven для запуска компонента производителя:

$ cd producer
$ mvn quarkus:dev

Компонент producerначинает генерировать сообщения с цитатами для специальной quotesтемы в экземпляре Kafka.

Приложение Quarkus также создало артефакт схемы с идентификатором quotes-valueв экземпляре Service Registry. Производитель использует артефакт схемы для проверки того, что каждое сообщение, представляющее цитату, соответствует определенной структуре. Чтобы просмотреть содержимое артефакта схемы, созданного приложением Quarkus, выполните следующую команду:

$ rhoas service-registry artifact get --artifact-id quotes-value

Результат:

{
  "type": "record",
  "name": "Quote",
  "namespace": "org.acme.kafka.quarkus",
  "fields": [
    {
      "name": "id",
      "type": {
        "type": "string",
        "avro.java.string": "String"
      }
    },
    {
      "name": "price",
      "type": "int"
    }
  ]
}

Затем, когда производитель все еще работает, используйте Apache Maven для запуска компонента-потребителя:

$ cd consumer
$ mvn quarkus:dev

Компонент-потребитель потребляет поток котировок и отображает их на вашей локальной веб-странице по адресу http://localhost:8080/quotes.html. Компонент-потребитель также использует quotes-valueартефакт схемы для проверки того, что сообщения соответствуют структуре, определенной в схеме.

На рис. 2 показан пример вывода, отображаемого на веб-странице.

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

В заключительных разделах этой записи блога мы кратко рассмотрим два других варианта использования: использование контекстов службы для подключения приложений в Red Hat OpenShift и совместное использование контекстов службы с другими членами команды.

Использование сервисных контекстов для подключения приложений на основе OpenShift

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

$ rhoas generate-config --type secret --output-file ./rhoas-services-secret.yaml

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

  • Решение для управления секретами, такое как Hashicorp Vault
  • Плагин helm- secrets
  • Шифрование и отправка секрета в репозиторий GitHub

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

$ oc apply -f ./rhoas-services-secret.yaml

Когда вы применили секрет к проекту OpenShift, вы можете обратиться к секрету из различных ресурсов, включая шаблоны приложений OpenShift, сборки Source-to-Image (S2I), диаграммы Helm и конфигурации привязки службы.

Совместное использование контекстов службы

Чтобы поделиться контекстом с другими членами команды, вам просто нужно поделиться файлом конфигурации контекста. Например, вы можете отправить файл в общий репозиторий GitHub, как описано в этом разделе.

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

$ rhoas context status

Когда у вас есть путь к файлу, вы можете скопировать его в место, например, в локальный репозиторий Git. Ниже приведен пример для Linux:

$ cp <path-to-context-file> ./profiles.json

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

Теперь предположим, что другой член команды хочет использовать общий контекст. Когда у этого члена команды есть файл контекста (например, он извлек его из общего репозитория), он должен определить переменную среды с именем RHOAS_CONTEXT, которая указывает на файл контекста. Ниже приведен пример для Linux:

$ export RHOAS_CONTEXT=./profiles.json

Сервисные контексты: быстрые, безопасные и масштабируемые

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

Ссылка: https://developers.redhat.com/articles/2022/07/18/simplify-client-connection-configurations-service-contexts#sharing_service_contexts

#openshift #redhat 

Как контексты службы OpenShift упрощают клиентские подключения
加藤  七夏

加藤 七夏

1658215022

OpenShift 服務上下文如何簡化客戶端連接

Red Hat OpenShift 應用程序服務rhoas的命令行界面 (CLI)的最新版本添加了一個強大而靈活的功能,稱為服務上下文,它可以比以往更輕鬆地將客戶端連接到您的 OpenShift 應用程序服務實例。本文說明了這一新功能,並展示了它如何加速基於流的應用程序的開發工作流程。

服務上下文促進客戶端連接

Red Hat OpenShift 應用程序服務,例如Red Hat OpenShift Streams for Apache KafkaRed Hat OpenShift Service Registry,是一種託管雲服務,可為在混合雲環境中構建、部署和擴展實時應用程序提供簡化的開發人員體驗。

OpenShift 應用程序服務 CLI 是用於管理應用程序服務的豐富命令行界面。借助新的服務上下文功能,您可以使用 CLI 為特定用例、項目或環境定義服務實例集,如圖 1 所示。定義上下文後,單個命令即可生成所需的連接配置信息通過客戶端應用程序。

上下文表示專用於特定目的的服務集合。

圖 1:上下文表示專用於特定目的的服務集合。

因此,服務上下文使您能夠在定義的服務實例集之間輕鬆切換,並為這些實例快速可靠地生成連接配置。與需要您為不同語言的獨立服務實例和應用程序創建單獨的配置文件的耗時且容易出錯的工作流相比,此過程顯著改進。

本文展示了服務上下文在哪些方面表現出色,以及為什麼我們很高興推出此功能。

首先,我們將介紹一個實際示例,該示例使用服務上下文將本地客戶端應用程序連接到 OpenShift 應用程序服務中的某些實例。然後我們將了解如何在基於 OpenShift 的應用程序中使用上下文,以及如何與其他團隊成員共享上下文。

將 Quarkus 應用程序連接到 OpenShift 應用程序服務

此示例使用服務上下文將示例Quarkus應用程序連接到 OpenShift 應用程序服務中的一些 Kafka 和 Service Registry 實例。Quarkus 應用程序生成一個引號流(實際上是隨機生成的字符串)並將它們顯示在網頁上。

一、打造全新的服務環境:

$ rhoas context create --name quotes-dev

您剛剛創建的上下文成為當前上下文。您可以創建多個上下文,在每個上下文中放置不同的服務,並為不同的開發人員提供上下文以使他們能夠訪問一組服務。

接下來,在當前上下文中創建一些 Kafka 和 Service Registry 實例:

$ rhoas kafka create --name example-kafka-instance --wait
$ rhoas service-registry create --name example-registry-instance

新的 Kafka 和 Service Registry 實例會自動添加到當前上下文中。您還可以使用context set-kafkacontext set-registry CLI 命令將現有的 Kafka 和 Service Registry 實例添加到當前上下文。

現在克隆一個示例 Quarkus 應用程序以在本地運行:

$ git clone https://github.com/redhat-developer/app-services-guides.git
$ cd app-services-guides/code-examples/quarkus-service-registry-quickstart/

示例 Quarkus 應用程序有兩個組件:生產者和消費者。生產者為 Kafka 主題生成報價消息流。消費者組件使用這些消息並在網頁上顯示它們的字符串。

Quarkus 應用程序需要quotes在您的 Kafka 實例中調用的 Kafka 主題。創建主題如下:

$ rhoas kafka topic create --name quotes

您已經為 Kafka 和 Service Registry 實例創建了一個上下文,因此您可以通過generate-config 命令生成將 Quarkus 應用程序連接到這些實例所需的配置信息:

$ rhoas generate-config --type env --output-file ./producer/.env

所有rhoas命令都針對當前上下文中的所有服務實例執行,因此您無需在上一個命令中顯式指定任何實例。這種廣泛的覆蓋範圍是服務環境的一個重要特徵。該功能使您能夠靈活地在大量服務實例之間快速無縫地切換,並針對它們運行 CLI 命令。

Quarkus 應用程序要求您的上下文的連接配置信息對生產者和消費者都可用。您之前在生產者目錄中生成了配置,因此您可以簡單地將相同的.env文件複製到消費者目錄中:

$ cp ./producer/.env ./consumer/.env 

對於您定義的上下文,.env文件的內容應如下所示:

## Generated by rhoas cli

## Kafka Configuration
KAFKA_HOST=test-insta-ca---q---mrrjobj---a.bf2.kafka.rhcloud.com:443

## Service Registry Configuration
SERVICE_REGISTRY_URL=https://bu98.serviceregistry.rhcloud.com/t/cc8a243a-feed-4a4c-9394-5a35ce83cca5
SERVICE_REGISTRY_CORE_PATH=/apis/registry/v2
SERVICE_REGISTRY_COMPAT_PATH=/apis/ccompat/v6

## Authentication Configuration
RHOAS_CLIENT_ID=srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd
RHOAS_CLIENT_SECRET=001a40b1-9a63-4c70-beda-3447b64a7783
RHOAS_OAUTH_TOKEN_URL=https://identity.api.openshift.com/auth/realms/rhoas/protocol/openid-connect/token

generate-config命令創建了一個服務帳戶(在環境變量 name 下RHOAS_CLIENT_ID)以在您的上下文中使用 Kafka 和 Service Registry 實例對客戶端應用程序進行身份驗證。要使服務帳戶能夠使用這些實例,您需要授予服務帳戶對實例的訪問權限:

$ rhoas kafka acl grant-access --producer --consumer --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd --topic quotes --group all
$ rhoas service-registry role add --role manager --service-account srvc-acct-45038cc5-0eb1-496f-a678-24ca7ed0a7bd 

您之前使該.env文件對 Quarkus 應用程序的生產者和消費者組件都可用。現在使用Apache Maven運行生產者組件:

$ cd producer
$ mvn quarkus:dev

producer組件開始為quotesKafka 實例中的專用主題生成報價消息。

quotes-valueQuarkus 應用程序還在Service Registry 實例中創建了一個 ID 為的模式工件。生產者使用模式工件來驗證表示報價的每條消息是否符合定義的結構。要查看 Quarkus 應用程序創建的架構工件的內容,請運行以下命令:

$ rhoas service-registry artifact get --artifact-id quotes-value

輸出是:

{
  "type": "record",
  "name": "Quote",
  "namespace": "org.acme.kafka.quarkus",
  "fields": [
    {
      "name": "id",
      "type": {
        "type": "string",
        "avro.java.string": "String"
      }
    },
    {
      "name": "price",
      "type": "int"
    }
  ]
}

接下來,在生產者仍在運行的情況下,使用 Apache Maven 運行消費者組件:

$ cd consumer
$ mvn quarkus:dev

消費者組件使用報價流並將它們顯示在您的本地網頁上http://localhost:8080/quotes.html。消費者組件還使用quotes-value模式工件來驗證消息是否符合模式中定義的結構。

圖 2 顯示了網頁上顯示的輸出示例。

此示例表明,在您定義上下文後,將客戶端應用程序連接到 OpenShift 應用程序服務就像為連接信息生成單個文件並將此文件複製到應用程序一樣簡單。

在這篇博文的最後部分,我們將簡要介紹另外兩個用例:使用服務上下文連接Red Hat OpenShift中的應用程序,以及與其他團隊成員共享服務上下文。

使用服務上下文連接基於 OpenShift 的應用程序

在前面的示例中,您生成了一個連接配置作為一組環境變量,這對於在本地運行的客戶端應用程序來說很方便。但是,如果您在 OpenShift 上運行基於容器的應用程序怎麼辦?好吧,服務上下文也使這變得容易。在這種情況下,您可以直接將連接配置信息生成為 OpenShift 機密文件:

$ rhoas generate-config --type secret --output-file ./rhoas-services-secret.yaml

生成密鑰後,您可以使用以下方法安全地存儲它:

您可以使用如下命令將密鑰應用於 OpenShift 項目:

$ oc apply -f ./rhoas-services-secret.yaml

將密鑰應用到 OpenShift 項目後,您可以從各種資源中引用密鑰,包括 OpenShift 應用程序模板、Source-to-Image (S2I) 構建、Helm 圖表和服務綁定配置。

共享服務上下文

要與其他團隊成員共享上下文,您只需要共享上下文的配置文件。例如,您可以將文件推送到本節所述的共享 GitHub 存儲庫。

不要將上下文的配置文件與.env您在本文前面為連接信息生成的環境變量文件混淆。相反,上下文文件列出了上下文中的服務實例。該文件包含 JSON 並存儲在本地計算機上。要獲取上下文文件的路徑,請運行以下命令:

$ rhoas context status

獲得文件路徑後,可以將其複製到本地 Git 存儲庫等位置。Linux 的示例如下:

$ cp <path-to-context-file> ./profiles.json

要與其他開發人員共享服務上下文,請將文件提交並推送到共享工作區域,例如團隊的 Git 存儲庫。甚至將上下文文件推送到公共存儲庫也是安全的,因為這些文件僅包含服務實例的標識符。

現在,假設另一個團隊成員想要使用共享上下文。當該團隊成員擁有上下文文件時(例如,他們從共享存儲庫中獲取它),他們必須定義一個名為RHOAS_CONTEXT指向上下文文件的環境變量。Linux 的示例如下:

$ export RHOAS_CONTEXT=./profiles.json

服務上下文:快速、安全和可擴展

本文展示了 CLI 的新服務上下文功能如何極大地簡化將客戶端應用程序連接到 Red Hat OpenShift 應用程序服務中的服務實例集的工作。這一強大而靈活的功能可以自動執行您之前在容易出錯的手動配置任務上花費的工作,並使您的團隊能夠專注於其最擅長的事情:開發出色的基於流的應用程序。

鏈接:https ://developers.redhat.com/articles/2022/07/18/simplify-client-connection-configurations-service-contexts#sharing_service_contexts

#openshift #redhat 

OpenShift 服務上下文如何簡化客戶端連接
Thierry  Perret

Thierry Perret

1657819020

Comment Exécuter VS Code Avec OpenShift Dev Spaces

Red Hat OpenShift Dev Spaces est un serveur d'environnement de développement natif OpenShift . La version 3.0 vient de sortir , et elle permet de choisir l'IDE qui sera inclus dans l'environnement de développement . Actuellement, les éditeurs inclus avec OpenShift Dev Spaces sont Eclipse Theia et JetBrains IntelliJ IDEA .

Qu'en est-il de Visual Studio Code ? Bien que nous prévoyions de l'utiliser comme IDE par défaut dans les futures versions d'OpenShift Dev Spaces, Visual Studio Code n'est pas inclus dans la version 3.0. Mais Eclipse Che , qui est le projet en amont pour OpenShift Dev Spaces, l'inclut déjà, et nous pouvons également l'utiliser facilement dans OpenShift Dev Spaces. Lisez la suite pour savoir comment cela fonctionne.

Sélectionnez Visual Studio Code comme éditeur d'un environnement Dev Space

Visual Studio Code est inclus dans le registre du plug-in Eclipse Che avec l'identifiant che-incubator/che-code/insiders. OpenShift Dev Spaces possède son propre registre de plugins interne, mais il peut également utiliser des registres externes, y compris le registre de plugins Eclipse Che en ligne . Nous pouvons référencer le registre Che en ligne à l'aide d'un fichier dans le référentiel Git ou via un paramètre d'URL. Nous allons jeter un coup d'œil rapide à chaque approche.

Option 1 : Ajout de che-editor.yaml dans le dépôt Git

Le moyen le plus simple d'utiliser Visual Studio Code pour un projet donné consiste à le référencer à partir d'un che-editor.yamlfichier dans un référentiel Git.

Créez un .chedossier et ajoutez un che-editor.yamlfichier avec le contenu suivant :

id: che-incubator/che-code/insiders
registryUrl: https://eclipse-che.github.io/che-plugin-registry/main/v3

La première ligne spécifie l'identifiant de l'éditeur. La deuxième ligne contient l'URL du registre du plugin où l'éditeur est publié. Nous utilisons le registre en ligne du plugin Eclipse Che dans cet exemple.

Il suffit de valider et de pousser la modification vers le référentiel Git du projet (Figure 1). Une fois le fichier poussé, tout environnement de développement à distance OpenShift Dev Spaces démarré à l'aide de l'URL du référentiel Git (GitHub, GitLab et Bitbucket sont pris en charge) utilisera Visual Studio Code comme éditeur.

Ajout du fichier .che/che-editor.yaml dans un dépôt git

Figure 1 : Ajout du fichier .che/che-editor.yaml dans un dépôt Git

Visual Studio Code n'est pas le seul éditeur pouvant être utilisé à partir du registre en ligne du plug-in Che. Voici une liste des identifiants d'éditeurs qui peuvent être référencés dans.che/che-editor.yaml :

ÉditeurID de l'éditeur dans le registre du plugin Che
Code Visual Studioche-incubator/che-code/insiders
JetBrains IntelliJ IDEA

che-incubator/che-idea/next

che-incubator/che-idea/latest

JetBrains PyCharm

che-incubator/che-pycharm/next

che-incubator/che-pycharm/latest

Option 2 : Utiliser le paramètre d'URL che-editor

Il n'est pas toujours possible d'ajouter le fichier .che/che-editor.yamldans un référentiel Git. Dans ces cas, il est toujours possible de spécifier l'éditeur à l'aide du che-editorparamètre URL :

https://<devspaces-hostname>#<git-repository-url>?che-editor=<editor-definition-url>

Voici un exemple d'une telle URL :

https://devspaces.apps.mloriedo-devworkspaces.devcluster.openshift.com/#https://github.com/devfile/api?che-editor=https://eclipse-che.github.io/che-plugin-registry/main/v3/plugins/che-incubator/che-code/insiders/devfile.yaml

Utilisation du paramètre d'URL che-editor

Figure 2 : Utilisation du paramètre d'URL che-editor

Voici une liste des définitions d'éditeurs disponibles dans le registre du plugin Che qui peuvent être utilisées dans le che-editorparamètre URL :

ÉditeurLien vers la définition du registre Che Plugin
Code Visual Studiodevfile.yaml
JetBrains IntelliJ IDEA

devfile.yaml (dernière version)

devfile.yaml (prochaine version la plus récente)

JetBrains PyCharm

devfile.yaml (dernière version)

devfile.yaml (prochaine version la plus récente)

Quelles sont les extensions Visual Studio Code disponibles ?

Le binaire Visual Studio Code inclus dans le registre du plug-in Che est préconfiguré pour utiliser le registre Open VSX en ligne , qui contient des milliers d'extensions et appartient à la Fondation Eclipse. Ces extensions peuvent être installées à partir de Visual Studio Code lui-même comme d'habitude (Figure 3).

Parcourir et installer les extensions Visual Studio Code à partir d'Open VSX

Figure 3 : Parcourir et installer les extensions Visual Studio Code à partir d'Open VSX

L'utilisation d'extensions Open VSX dans des scénarios d'espacement d'air n'est actuellement pas prise en charge. Nous travaillons sur une version hors ligne d'Open VSX Registry qui peut être utilisée avec OpenShift Dev Spaces pour prendre en charge de tels environnements, mais qui ne sera pas disponible avant OpenShift Dev Spaces 3.3.

Visual Studio Code est-il pris en charge pour OpenShift Dev Spaces ?

Visual Studio Code n'est actuellement qu'un projet communautaire et, en tant que tel, il n'est pas inclus dans le support client d'OpenShift Dev Spaces. (Le reste de votre environnement OpenShift Dev Spaces est entièrement pris en charge ; seul l'éditeur modifié ne serait pas entièrement pris en charge si vous l'installiez.) Pour ce changement, Red Hat offrira une assistance « commercialement raisonnable », ce qui signifie que nous essaierons de vous aider mais ne peut pas offrir les mêmes garanties (avec les SLA) que nous offrons pour le reste des OpenShift Dev Spaces.

Quelle est la différence entre cet éditeur et Microsoft Visual Studio Code ?

L'éditeur basé sur Visual Studio Code utilisé par Eclipse Che, appelé che-code , est une personnalisation de Visual Studio Code Open Source (Code OSS). Ce n'est pas un fork de Code OSS (le code source est inclus en tant que sous- arborescence Git ) et cela facilite la récupération automatique des dernières modifications de Code OSS plusieurs fois par jour (actuellement toutes les quatre heures).

Les che-codepersonnalisations incluent :

  • Icônes et étiquettes Eclipse Che (branding)
  • Quelques extensions intégrées supplémentaires (surveillance des ressources, plug-in de port, commandes devfile, projets et prise en charge des terminaux distants)
  • La configuration pour utiliser le registre Open VSX en ligne
  • Une désactivation de la télémétrie Microsoft

Microsoft Visual Studio Code est également construit sur Code OSS, mais inclut certaines extensions intégrées à source fermée, utilise le marché des extensions Microsoft Visual Studio Code et a activé la télémétrie.

Nous avons envisagé d'utiliser un projet existant tel que coder ou openvscode -server pour exécuter Visual Studio Code dans le navigateur. Mais ce sont des fourches (ce qui les rend plus difficiles à rebaser), et le code pour exécuter Visual Studio Code dans le navigateur est, à partir de maintenant, open source et disponible dans Code OSS, donc nous ne pensons pas qu'il y ait actuellement une valeur à utiliser un projet intermédiaire.

Quelle est la feuille de route pour inclure Visual Studio Code dans OpenShift Dev Spaces ?

L'éditeur OpenShift Dev Spaces par défaut est toujours Eclipse Theia, mais le nombre d'extensions Visual Studio Code pouvant être exécutées correctement par Theia est limité. C'est notre principal problème depuis trois ans. Les développeurs ne se soucient pas beaucoup de la question de Visual Studio Code contre Eclipse Theia, mais ils veulent exécuter la myriade d'extensions disponibles.

Notre objectif principal pour le troisième trimestre 2022 est d'inclure un éditeur basé sur Code OSS utilisant Open VSX Registry dans OpenShift Dev Spaces et d'en faire l'éditeur par défaut. Pour ce faire, nous comblons actuellement l'écart de fonctionnalités avec Theia. En particulier, nous travaillons sur un mécanisme d'inactivité pour arrêter les environnements qui ont été inactifs pendant un certain temps, ainsi que sur la prise en charge des environnements à espace d'air.

Est-il possible d'utiliser Visual Studio Code sur Developer Sandbox ?

La Red Hat Developer Sandbox n'a pas encore été mise à jour vers OpenShift Dev Spaces, et il n'est pas possible d'utiliser CodeReady Workspaces 2.15 pour provisionner des environnements de développement basés sur Visual Studio Code. Mais DevWorkspace Operator, le nouveau moteur d'environnements de développement utilisé par OpenShift Dev Spaces, est installé sur Developer Sandbox (car le terminal Web en dépend) et prend en charge l'exécution d'un environnement de développement basé sur Visual Studio Code.

Voici quelques instructions de ligne de commande pour le faire à partir du terminal Web OpenShift. Vous pouvez voir les résultats dans la figure 4.

VSCODE_SAMPLE_DW="https://eclipse-che.github.io/che-devfile-registry/main/devfiles/nodejs/devworkspace-che-code-insiders.yaml"
 
curl  -sSL "${VSCODE_SAMPLE_DW}" | sed 's/^[[:space:]]\{8,\}container:/        container:^          env: [{name: CODE_HOST, value: "0.0.0.0"}]/g' | # <-- CHE IS NOT THERE
sed 's/template:/template:^    attributes:^      controller.devfile.io\/storage-type: ephemeral/g' | # <-- EPHEMERAL IS FASTER
sed 's/volume: {}/volume: {ephemeral: true}/g' |
sed '/tkn=eclipse-che/d' |
tr '^' '\n' | \
oc apply -f -
oc get dw nodejs-web-app --watch

Exécution de Visual Studio Code dans Red Hat Developer Sandbox à l'aide de l'opérateur DevWorkspace

Figure 4 : Exécution de Visual Studio Code dans Red Hat Developer Sandbox à l'aide de l'opérateur DevWorkspace

Nous travaillons toujours sur l'extension de la prise en charge des éditeurs dans OpenShift Dev Spaces. Mais en suivant les étapes décrites ici, les utilisateurs peuvent tirer parti de leur familiarité avec Visual Studio Code et son écosystème d'extensions aujourd'hui.

Un merci spécial à Rick Wagner et Florent Benoit pour leur relecture et leurs suggestions pour cet article.

Lien : https://developers.redhat.com/articles/2022/07/12/how-run-vs-code-openshift-dev-spaces#is_it_possible_to_use_visual_studio_code_on_the_developer_sandbox_

#visualstudiocode #openshift 

Comment Exécuter VS Code Avec OpenShift Dev Spaces

Как запустить код VS с OpenShift Dev Spaces

Red Hat OpenShift Dev Spaces — это собственный сервер среды разработки OpenShift . Только что выпущенная версия 3.0 позволяет вам выбрать IDE, которая будет включена в среду разработки . В настоящее время в состав OpenShift Dev Spaces входят редакторы Eclipse Theia и JetBrains IntelliJ IDEA .

А как насчет кода Visual Studio? Хотя мы планируем использовать его в качестве IDE по умолчанию в будущих версиях OpenShift Dev Spaces, код Visual Studio не включен в версию 3.0. Но Eclipse Che , который является исходным проектом для OpenShift Dev Spaces, уже включает его, и мы можем легко использовать его и в OpenShift Dev Spaces. Читайте дальше, чтобы узнать, как это работает.

Выберите Visual Studio Code в качестве редактора среды Dev Space.

Код Visual Studio включен в реестр подключаемых модулей Eclipse Che с идентификатором che-incubator/che-code/insiders. OpenShift Dev Spaces имеет собственный внутренний реестр плагинов, но может использовать и внешние реестры, включая онлайн-реестр плагинов Eclipse Che . Мы можем ссылаться на онлайн-реестр Che, используя файл в репозитории Git или через параметр URL. Мы кратко рассмотрим каждый подход.

Вариант 1: Добавление che-editor.yaml в репозиторий Git

Самый простой способ использовать код Visual Studio для данного проекта — создать ссылку на него из che-editor.yamlфайла в репозитории Git.

Создайте .cheпапку и добавьте che-editor.yamlв нее файл со следующим содержимым:

id: che-incubator/che-code/insiders
registryUrl: https://eclipse-che.github.io/che-plugin-registry/main/v3

В первой строке указывается идентификатор редактора. Вторая строка содержит URL-адрес реестра плагинов, в котором опубликован редактор. В этом примере мы используем онлайн-реестр плагинов Eclipse Che.

Просто зафиксируйте и отправьте изменение в репозиторий Git проекта (рис. 1). После отправки файла любая удаленная среда разработки OpenShift Dev Spaces, запущенная с использованием URL-адреса репозитория Git (поддерживаются GitHub, GitLab и Bitbucket), будет использовать Visual Studio Code в качестве редактора.

Добавление файла .che/che-editor.yaml в репозиторий git

Рисунок 1: Добавление файла .che/che-editor.yaml в репозиторий Git

Visual Studio Code — не единственный редактор, который можно использовать из онлайн-реестра плагинов Che. Вот список идентификаторов редакторов, на которые можно ссылаться из .che/che-editor.yaml:

редакторИдентификатор редактора в реестре плагинов Che
Код Visual Studioche-incubator/che-code/insiders
JetBrains IntelliJ ИДЕЯ

che-incubator/che-idea/next

che-incubator/che-idea/latest

JetBrains PyCharm

che-incubator/che-pycharm/next

che-incubator/che-pycharm/latest

Вариант 2: Использование че-редактора параметра URL

Не всегда возможно добавить файл .che/che-editor.yamlв репозиторий Git. В этих случаях по-прежнему можно указать редактор с помощью che-editorпараметра URL:

https://<devspaces-hostname>#<git-repository-url>?che-editor=<editor-definition-url>

Вот пример такого URL:

https://devspaces.apps.mloriedo-devworkspaces.devcluster.openshift.com/#https://github.com/devfile/api?che-editor=https://eclipse-che.github.io/che-plugin-registry/main/v3/plugins/che-incubator/che-code/insiders/devfile.yaml

Использование параметра URL-адреса che-editor

Рисунок 2: Использование параметра URL-адреса che-editor

Вот список доступных определений редакторов в реестре плагинов Che, которые можно использовать в che-editorпараметре URL:

редакторСсылка на определение реестра плагинов Che
Код Visual Studiodevfile.yaml
JetBrains IntelliJ ИДЕЯ

devfile.yaml (последняя версия)

devfile.yaml (следующая самая последняя версия)

JetBrains PyCharm

devfile.yaml (последняя версия)

devfile.yaml (следующая самая последняя версия)

Какие расширения Visual Studio Code доступны?

Бинарный код Visual Studio Code, включенный в реестр подключаемых модулей Che, предварительно настроен для использования онлайнового реестра Open VSX , который содержит тысячи расширений и принадлежит Eclipse Foundation. Эти расширения можно установить из Visual Studio Code, как обычно (рис. 3).

Просмотр и установка расширений Visual Studio Code из Open VSX

Рис. 3. Просмотр и установка расширений Visual Studio Code из Open VSX

Использование расширений Open VSX в сценариях с воздушным зазором в настоящее время не поддерживается. Мы работаем над автономной версией Open VSX Registry, которую можно использовать с OpenShift Dev Spaces для поддержки таких сред, но она не будет доступна до OpenShift Dev Spaces 3.3.

Поддерживается ли Visual Studio Code для OpenShift Dev Spaces?

Visual Studio Code в настоящее время является только проектом сообщества и поэтому не включен в поддержку клиентов OpenShift Dev Spaces. (Остальная часть вашей среды OpenShift Dev Spaces полностью поддерживается; только измененный редактор не будет полностью поддерживаться, если вы его установите.) Для этого изменения Red Hat предложит «коммерчески обоснованную» поддержку, что означает, что мы постараемся вам помочь. но не может дать такие же гарантии (с соглашениями об уровне обслуживания), которые мы даем для остальных пространств разработки OpenShift.

В чем разница между этим редактором и кодом Microsoft Visual Studio?

Редактор на основе кода Visual Studio, используемый Eclipse Che, называется che-code и представляет собой настройку Visual Studio Code с открытым исходным кодом (Code OSS). Это не форк Code OSS (исходный код включен в виде поддерева Git ), и это позволяет легко автоматически получать последние изменения из Code OSS несколько раз в день (в настоящее время каждые четыре часа).

Настройки che-codeвключают в себя:

  • Иконки и этикетки Eclipse Che (брендинг)
  • Несколько дополнительных встроенных расширений (мониторинг ресурсов, плагин порта, команды devfile, проекты и поддержка удаленного терминала)
  • Конфигурация для использования онлайн-реестра Open VSX Registry
  • Отказ от телеметрии Microsoft

Microsoft Visual Studio Code также построен на основе Code OSS, но включает некоторые встроенные расширения с закрытым исходным кодом, использует рынок расширений Microsoft Visual Studio Code и включает телеметрию.

Мы рассмотрели возможность использования существующего проекта, такого как coder или openvscode-server , для запуска кода Visual Studio в браузере. Но это форки (что усложняет их перебазирование), а код для запуска Visual Studio Code в браузере на данный момент имеет открытый исходный код и доступен в Code OSS, поэтому мы не думаем, что в настоящее время есть какая-либо ценность для использования промежуточный проект.

Каков план включения Visual Studio Code в OpenShift Dev Spaces?

Редактором OpenShift Dev Spaces по умолчанию по-прежнему является Eclipse Theia, но количество расширений Visual Studio Code, которые могут быть правильно запущены Theia, ограничено. Это была наша главная проблема на протяжении последних трех лет. Разработчиков не очень волнует вопрос о Visual Studio Code и Eclipse Theia, но они хотят запускать множество доступных расширений.

Наша главная цель в третьем квартале 2022 года — включить редактор на основе Code OSS с использованием Open VSX Registry в OpenShift Dev Spaces и сделать его редактором по умолчанию. Для этого мы в настоящее время устраняем пробел в функциях с помощью Theia. В частности, мы работаем над механизмом бездействия для остановки сред, которые были неактивны в течение заданного периода времени, а также работаем над поддержкой сред с воздушным зазором.

Можно ли использовать код Visual Studio в песочнице разработчика?

Песочница Red Hat Developer Sandbox еще не обновлена ​​до OpenShift Dev Spaces, и нельзя использовать CodeReady Workspaces 2.15 для подготовки сред разработки на основе кода Visual Studio. Но DevWorkspace Operator, новый движок сред разработки, используемый OpenShift Dev Spaces, устанавливается в песочнице разработчика (поскольку веб-терминал зависит от него) и поддерживает запуск среды разработки на основе кода Visual Studio.

Вот несколько инструкций командной строки, чтобы сделать это из веб-терминала OpenShift. Вы можете увидеть результаты на рисунке 4.

VSCODE_SAMPLE_DW="https://eclipse-che.github.io/che-devfile-registry/main/devfiles/nodejs/devworkspace-che-code-insiders.yaml"
 
curl  -sSL "${VSCODE_SAMPLE_DW}" | sed 's/^[[:space:]]\{8,\}container:/        container:^          env: [{name: CODE_HOST, value: "0.0.0.0"}]/g' | # <-- CHE IS NOT THERE
sed 's/template:/template:^    attributes:^      controller.devfile.io\/storage-type: ephemeral/g' | # <-- EPHEMERAL IS FASTER
sed 's/volume: {}/volume: {ephemeral: true}/g' |
sed '/tkn=eclipse-che/d' |
tr '^' '\n' | \
oc apply -f -
oc get dw nodejs-web-app --watch

Запуск кода Visual Studio в песочнице Red Hat Developer с помощью оператора DevWorkspace

Рис. 4. Запуск кода Visual Studio в песочнице Red Hat Developer Sandbox с помощью оператора DevWorkspace.

Мы все еще работаем над расширением поддержки редакторов в OpenShift Dev Spaces. Но, следуя описанным здесь шагам, пользователи могут воспользоваться своим знакомством с Visual Studio Code и его экосистемой расширений уже сегодня.

Особая благодарность Рику Вагнеру и Флорану Бенуа за их обзор и предложения для этой статьи.

Ссылка: https://developers.redhat.com/articles/2022/07/12/how-run-vs-code-openshift-dev-spaces#is_it_possible_to_use_visual_studio_code_on_the_developer_sandbox_

#visualstudiocode #openshift 

Как запустить код VS с OpenShift Dev Spaces
高橋  陽子

高橋 陽子

1657797300

如何使用 OpenShift 開發空間運行 VS 代碼

Red Hat OpenShift Dev Spaces 是一個OpenShift原生開發環境服務器。3.0 版剛剛發布它允許您選擇將包含在開發環境中的 IDE。目前,OpenShift Dev Spaces 包含的編輯器是Eclipse TheiaJetBrains IntelliJ IDEA

Visual Studio 代碼呢?儘管我們計劃在未來版本的 OpenShift Dev Spaces 中將其用作默認 IDE,但 Visual Studio Code 並未包含在 3.0 版中。但是OpenShift Dev Spaces 的上游項目Eclipse Che已經包含了它,我們也可以在 OpenShift Dev Spaces 中輕鬆使用它。請繼續閱讀以了解其工作原理。

選擇 Visual Studio Code 作為 Dev Space 環境的編輯器

Visual Studio Code 包含在 Eclipse Che 插件註冊表中,標識符為che-incubator/che-code/insiders。OpenShift Dev Spaces 有自己的內部插件註冊表,但它也可以使用外部註冊表,包括在線 Eclipse Che 插件註冊表。我們可以使用 Git 存儲庫中的文件或通過 URL 參數引用在線 Che 註冊表。我們將快速瀏覽每種方法。

選項 1:在 Git 存儲庫中添加 che-editor.yaml

將 Visual Studio Code 用於給定項目的最簡單方法是從che-editor.yamlGit 存儲庫中的文件引用它。

創建一個.che文件夾並添加一個che-editor.yaml包含以下內容的文件:

id: che-incubator/che-code/insiders
registryUrl: https://eclipse-che.github.io/che-plugin-registry/main/v3

第一行指定編輯器的標識符。第二行包含發布編輯器的插件註冊表的 URL。在此示例中,我們使用在線 Eclipse Che 插件註冊表。

只需提交更改並將更改推送到項目 Git 存儲庫(圖 1)。推送文件後,任何使用 Git 存儲庫 URL(支持 GitHub、GitLab 和 Bitbucket)啟動的 OpenShift Dev Spaces 遠程開發環境都將使用 Visual Studio Code 作為編輯器。

在 git 存儲庫中添加文件 .che/che-editor.yaml

圖 1:在 Git 存儲庫中添加文件 .che/che-editor.yaml

Visual Studio Code 不是唯一可以從在線 Che 插件註冊表中使用的編輯器。以下是可以在 from 中引用的編輯器 ID 列表.che/che-editor.yaml

編輯Che 插件註冊表中的編輯器 ID
視覺工作室代碼che-incubator/che-code/insiders
JetBrains IntelliJ IDEA

che-incubator/che-idea/next

che-incubator/che-idea/latest

JetBrains PyCharm

che-incubator/che-pycharm/next

che-incubator/che-pycharm/latest

選項 2:使用 URL 參數 che-editor

並不總是可以將文件添加.che/che-editor.yaml到 Git 存儲庫中。在這些情況下,仍然可以使用che-editorURL 參數指定編輯器:

https://<devspaces-hostname>#<git-repository-url>?che-editor=<editor-definition-url>

以下是此類 URL 的示例:

https://devspaces.apps.mloriedo-devworkspaces.devcluster.openshift.com/#https://github.com/devfile/api?che-editor=https://eclipse-che.github.io/che-plugin-registry/main/v3/plugins/che-incubator/che-code/insiders/devfile.yaml

使用 che-editor URL 參數

圖 2:使用 che-editor URL 參數

che-editor以下是可在URL 參數中使用的 Che 插件註冊表中可用編輯器定義的列表:

編輯鏈接到 Che Plugin Registry 定義
視覺工作室代碼開發文件.yaml
JetBrains IntelliJ IDEA

devfile.yaml(最新版​​本)

devfile.yaml(下一個最新版本)

JetBrains PyCharm

devfile.yaml(最新版​​本)

devfile.yaml(下一個最新版本)

有哪些 Visual Studio Code 擴展可用?

Che 插件註冊表中包含的 Visual Studio Code 二進製文件已預先配置為使用在線Open VSX 註冊表,該註冊表包含數千個擴展,歸 Eclipse 基金會所有。可以像往常一樣從 Visual Studio Code 本身安裝這些擴展(圖 3)。

從 Open VSX 瀏覽和安裝 Visual Studio Code 擴展

圖 3:從 Open VSX 瀏覽和安裝 Visual Studio Code 擴展

目前不支持在氣隙方案中使用 Open VSX 擴展。我們正在開發可與 OpenShift Dev Spaces 一起使用以支持此類環境的 Open VSX Registry 脫機版本,但在 OpenShift Dev Spaces 3.3 之前將不可用。

OpenShift 開發空間是否支持 Visual Studio Code?

Visual Studio Code 目前只是一個社區項目,因此,它不包含在 OpenShift Dev Spaces 客戶支持中。(完全支持您的 OpenShift Dev Spaces 環境的其餘部分;如果您安裝了更改的編輯器,則不會完全支持它。)對於此更改,Red Hat 將提供“商業上合理的”支持,這意味著我們將盡力幫助您但不能做出我們為 OpenShift 開發空間的其餘部分做出的相同保證(使用 SLA)。

這個編輯器和 Microsoft Visual Studio Code 有什麼區別?

Eclipse Che 使用的基於 Visual Studio Code 的編輯器,稱為che-code,是Visual Studio Code Open Source (Code OSS) 的定制。它不是 Code OSS 的一個分支(源代碼包含在Git 子樹中),這使得每天多次(當前每四個小時)從 Code OSS 自動獲取最新更改變得容易。

che-code定制包括:

  • Eclipse Che 圖標和標籤(品牌)
  • 一些額外的內置擴展(資源監控、端口插件、devfile 命令、項目和遠程終端支持)
  • 使用在線 Open VSX 註冊表的配置
  • 選擇退出 Microsoft 遙測

Microsoft Visual Studio Code 也構建在 Code OSS 之上,但包括一些封閉源代碼的內置擴展,使用 Microsoft Visual Studio Code 擴展市場,並已打開遙測。

我們考慮使用coderopenvscode-server等現有項目在瀏覽器中運行 Visual Studio Code。但是這些是分叉(使它們更難變基),並且在瀏覽器中運行 Visual Studio Code 的代碼目前是開源的並且在 Code OSS 中可用,所以我們認為目前使用沒有任何價值一個中間項目。

在 OpenShift Dev Spaces 中包含 Visual Studio Code 的路線圖是什麼?

默認的 OpenShift Dev Spaces 編輯器仍然是 Eclipse Theia,但是 Theia 可以正常運行的 Visual Studio Code 擴展的數量是有限的。這是我們過去三年的主要問題。開發人員不太關心 Visual Studio Code 與 Eclipse Theia 的問題,但他們希望運行無數可用的擴展。

我們 2022 年第 3 季度的主要目標是在 OpenShift Dev Spaces 中包含一個使用 Open VSX Registry 的基於Code OSS的編輯器,並使其成為默認編輯器。為此,我們目前正在縮小與 Theia 的功能差距。特別是,我們正在研究一種空閒機制,以停止在給定時間內處於非活動狀態的環境,並致力於支持氣隙環境。

是否可以在開發人員沙盒上使用 Visual Studio Code?

Red Hat Developer Sandbox尚未更新到 OpenShift Dev Spaces,並且無法使用 CodeReady Workspaces 2.15 來配置基於 Visual Studio Code 的開發環境。但是 OpenShift Dev Spaces 使用的新開發環境引擎 DevWorkspace Operator 安裝在 Developer Sandbox 上(因為 Web Terminal 依賴於它),它支持運行基於 Visual Studio Code 的開發環境。

以下是一些從 OpenShift Web 終端執行此操作的命令行說明。您可以在圖 4 中看到結果。

VSCODE_SAMPLE_DW="https://eclipse-che.github.io/che-devfile-registry/main/devfiles/nodejs/devworkspace-che-code-insiders.yaml"
 
curl  -sSL "${VSCODE_SAMPLE_DW}" | sed 's/^[[:space:]]\{8,\}container:/        container:^          env: [{name: CODE_HOST, value: "0.0.0.0"}]/g' | # <-- CHE IS NOT THERE
sed 's/template:/template:^    attributes:^      controller.devfile.io\/storage-type: ephemeral/g' | # <-- EPHEMERAL IS FASTER
sed 's/volume: {}/volume: {ephemeral: true}/g' |
sed '/tkn=eclipse-che/d' |
tr '^' '\n' | \
oc apply -f -
oc get dw nodejs-web-app --watch

使用 DevWorkspace Operator 在 Red Hat Developer Sandbox 中運行 Visual Studio Code

圖 4:使用 DevWorkspace Operator 在 Red Hat Developer Sandbox 中運行 Visual Studio Code

我們仍在努力擴展 OpenShift Dev Spaces 中的編輯器支持。但通過遵循此處概述的步驟,用戶可以利用他們對 Visual Studio Code 及其當今擴展生態系統的熟悉。

特別感謝 Rick Wagner 和 Florent Benoit 對本文的審閱和建議。

鏈接:https ://developers.redhat.com/articles/2022/07/12/how-run-vs-code-openshift-dev-spaces#is_it_possible_to_use_visual_studio_code_on_the_developer_sandbox_

#visualstudiocode #openshift 

如何使用 OpenShift 開發空間運行 VS 代碼
Dang  Tu

Dang Tu

1657786420

Cách Chạy Mã VS Với OpenShift Dev Spaces

Red Hat OpenShift Dev Spaces là một máy chủ môi trường dành cho nhà phát triển OpenShift -native. Phiên bản 3.0 vừa được phát hànhnó cho phép bạn chọn IDE sẽ được đưa vào môi trường phát triển . Hiện tại, các trình soạn thảo đi kèm với OpenShift Dev Spaces là Eclipse TheiaJetBrains IntelliJ IDEA .

Điều gì về Visual Studio Code? Mặc dù chúng tôi dự định sử dụng nó làm IDE mặc định trong các phiên bản tương lai của OpenShift Dev Spaces, nhưng Visual Studio Code không được bao gồm trong phiên bản 3.0. Nhưng Eclipse Che , là dự án ngược dòng cho OpenShift Dev Spaces, đã bao gồm nó và chúng ta cũng có thể dễ dàng sử dụng nó trong OpenShift Dev Spaces. Đọc tiếp để tìm hiểu cách hoạt động của nó.

Chọn Visual Studio Code làm trình chỉnh sửa môi trường Dev Space

Visual Studio Code được bao gồm trong sổ đăng ký plugin Eclipse Che với số nhận dạng che-incubator/che-code/insiders. OpenShift Dev Spaces có sổ đăng ký plugin nội bộ của riêng mình, nhưng nó cũng có thể sử dụng các đăng ký bên ngoài, bao gồm cả sổ đăng ký plugin Eclipse Che trực tuyến . Chúng tôi có thể tham khảo sổ đăng ký Che trực tuyến bằng cách sử dụng tệp trong kho lưu trữ Git hoặc thông qua tham số URL. Chúng tôi sẽ xem xét nhanh từng cách tiếp cận.

Tùy chọn 1: Thêm che-editor.yaml vào kho lưu trữ Git

Cách dễ nhất để sử dụng Visual Studio Code cho một dự án nhất định là tham chiếu nó từ một che-editor.yamltệp trong kho lưu trữ Git.

Tạo một .chethư mục và thêm một che-editor.yamltệp có nội dung sau:

id: che-incubator/che-code/insiders
registryUrl: https://eclipse-che.github.io/che-plugin-registry/main/v3

Dòng đầu tiên chỉ định định danh của trình soạn thảo. Dòng thứ hai chứa URL của sổ đăng ký plugin nơi trình chỉnh sửa được xuất bản. Chúng tôi đang sử dụng sổ đăng ký plugin Eclipse Che trực tuyến trong ví dụ này.

Chỉ cần cam kết và đẩy thay đổi vào kho lưu trữ Git của dự án (Hình 1). Khi tệp được đẩy, bất kỳ môi trường phát triển từ xa OpenShift Dev Spaces nào bắt đầu sử dụng URL kho lưu trữ Git (GitHub, GitLab và Bitbucket được hỗ trợ) sẽ sử dụng Visual Studio Code làm trình chỉnh sửa.

Thêm tệp .che / che-editor.yaml vào kho lưu trữ git

Hình 1: Thêm tệp .che / che-editor.yaml vào kho lưu trữ Git

Visual Studio Code không phải là trình chỉnh sửa duy nhất có thể được sử dụng từ sổ đăng ký plugin Che trực tuyến. Dưới đây là danh sách các ID trình chỉnh sửa có thể được tham chiếu từ .che/che-editor.yaml:

Biên tập viênID người chỉnh sửa trong sổ đăng ký plugin Che
Mã Visual Studioche-incubator/che-code/insiders
JetBrains IntelliJ IDEA

che-incubator/che-idea/next

che-incubator/che-idea/latest

JetBrains PyCharm

che-incubator/che-pycharm/next

che-incubator/che-pycharm/latest

Tùy chọn 2: Sử dụng tham số URL che-editor

Không phải lúc nào bạn cũng có thể thêm tệp .che/che-editor.yamlvào kho lưu trữ Git. Trong những trường hợp này, vẫn có thể chỉ định trình chỉnh sửa bằng cách sử dụng che-editortham số URL:

https://<devspaces-hostname>#<git-repository-url>?che-editor=<editor-definition-url>

Đây là một ví dụ về một URL như vậy:

https://devspaces.apps.mloriedo-devworkspaces.devcluster.openshift.com/#https://github.com/devfile/api?che-editor=https://eclipse-che.github.io/che-plugin-registry/main/v3/plugins/che-incubator/che-code/insiders/devfile.yaml

Sử dụng tham số URL che-editor

Hình 2: Sử dụng tham số URL che-editor

Dưới đây là danh sách các định nghĩa trình chỉnh sửa có sẵn trong sổ đăng ký plugin Che có thể được sử dụng trong che-editortham số URL:

Biên tập viênLiên kết đến định nghĩa Che Plugin Registry
Mã Visual Studiodevfile.yaml
JetBrains IntelliJ IDEA

devfile.yaml (phiên bản mới nhất)

devfile.yaml (phiên bản mới nhất tiếp theo)

JetBrains PyCharm

devfile.yaml (phiên bản mới nhất)

devfile.yaml (phiên bản mới nhất tiếp theo)

Có những phần mở rộng Visual Studio Code nào?

Mã nhị phân Visual Studio Code có trong sổ đăng ký plugin Che được cấu hình trước để sử dụng Đăng ký VSX mở trực tuyến , chứa hàng nghìn tiện ích mở rộng và thuộc sở hữu của Eclipse Foundation. Những phần mở rộng đó có thể được cài đặt từ chính Visual Studio Code như bình thường (Hình 3).

Duyệt và cài đặt tiện ích mở rộng Visual Studio Code từ Open VSX

Hình 3: Duyệt và cài đặt tiện ích mở rộng Visual Studio Code từ Open VSX

Việc sử dụng tiện ích mở rộng VSX mở trong các trường hợp không khí hiện không được hỗ trợ. Chúng tôi đang làm việc trên một phiên bản ngoại tuyến của Open VSX Registry có thể được sử dụng với OpenShift Dev Spaces để hỗ trợ những môi trường như vậy, nhưng phiên bản đó sẽ không khả dụng trước OpenShift Dev Spaces 3.3.

Mã Visual Studio có được hỗ trợ cho OpenShift Dev Spaces không?

Visual Studio Code hiện chỉ là một dự án cộng đồng và do đó, nó không được bao gồm trong bộ phận hỗ trợ khách hàng của OpenShift Dev Spaces. (Phần còn lại của môi trường OpenShift Dev Spaces của bạn được hỗ trợ đầy đủ; chỉ trình chỉnh sửa đã thay đổi sẽ không được hỗ trợ đầy đủ nếu bạn cài đặt nó.) Đối với thay đổi này, Red Hat sẽ cung cấp hỗ trợ "hợp lý về mặt thương mại", có nghĩa là chúng tôi sẽ cố gắng giúp bạn nhưng không thể đảm bảo tương tự (với SLA) mà chúng tôi thực hiện cho phần còn lại của OpenShift Dev Spaces.

Sự khác biệt giữa trình soạn thảo này và Microsoft Visual Studio Code là gì?

Trình soạn thảo dựa trên Visual Studio Code được Eclipse Che sử dụng, được gọi là che-code , là một tùy chỉnh của Visual Studio Code Open Source (Code OSS). Nó không phải là một nhánh của Code OSS (mã nguồn được bao gồm dưới dạng cây con Git ) và điều đó giúp bạn dễ dàng tự động tìm nạp những thay đổi mới nhất từ ​​Code OSS nhiều lần một ngày (hiện tại là bốn giờ một lần).

Các che-codetùy chỉnh bao gồm:

  • Biểu tượng và nhãn Eclipse Che (thương hiệu)
  • Một số tiện ích mở rộng tích hợp bổ sung (giám sát tài nguyên, plugin cổng, lệnh devfile, dự án và hỗ trợ thiết bị đầu cuối từ xa)
  • Cấu hình để sử dụng Open VSX Registry trực tuyến
  • Chọn không tham gia tính năng đo từ xa của Microsoft

Microsoft Visual Studio Code cũng được xây dựng dựa trên Code OSS, nhưng bao gồm một số tiện ích mở rộng tích hợp sẵn mã nguồn đóng, sử dụng thị trường tiện ích mở rộng Microsoft Visual Studio Code và đã bật tính năng đo từ xa.

Chúng tôi đã xem xét sử dụng một dự án hiện có như coder hoặc openvscode-server để chạy Visual Studio Code trong trình duyệt. Nhưng đó là những fork (khiến chúng khó rebase hơn) và mã để chạy Visual Studio Code trong trình duyệt, tính đến thời điểm hiện tại, là mã nguồn mở và có sẵn trong Code OSS, vì vậy chúng tôi không nghĩ rằng hiện tại có bất kỳ giá trị nào để sử dụng một dự án trung gian.

Lộ trình đưa Mã Visual Studio vào OpenShift Dev Spaces là gì?

Trình soạn thảo OpenShift Dev Spaces mặc định vẫn là Eclipse Theia, nhưng số lượng phần mở rộng Visual Studio Code có thể được Theia chạy đúng cách bị hạn chế. Đó là vấn đề chính của chúng tôi trong ba năm qua. Các nhà phát triển không quan tâm nhiều đến câu hỏi của Visual Studio Code so với Eclipse Theia, nhưng họ muốn chạy vô số các tiện ích mở rộng có sẵn trên mạng.

Mục tiêu chính của chúng tôi cho Q3 2022 là bao gồm trình soạn thảo dựa trên Code OSS sử dụng Open VSX Registry trong OpenShift Dev Spaces và đặt nó làm trình chỉnh sửa mặc định. Để làm được điều đó, chúng tôi hiện đang thu hẹp khoảng cách về tính năng với Theia. Đặc biệt, chúng tôi đang nghiên cứu cơ chế chạy không tải để dừng các môi trường không hoạt động trong một khoảng thời gian nhất định, cũng như nghiên cứu hỗ trợ cho các môi trường có không khí.

Có thể sử dụng Mã Visual Studio trên Hộp cát dành cho nhà phát triển không?

Red Hat Developer Sandbox chưa được cập nhật lên OpenShift Dev Spaces và không thể sử dụng CodeReady Workspaces 2.15 để cung cấp môi trường phát triển dựa trên Visual Studio Code . Nhưng DevWorkspace Operator, công cụ môi trường dành cho nhà phát triển mới được OpenShift Dev Spaces sử dụng, được cài đặt trên Developer Sandbox (vì Web Terminal phụ thuộc vào nó) và nó hỗ trợ chạy môi trường phát triển dựa trên Visual Studio Code.

Dưới đây là một số hướng dẫn dòng lệnh để thực hiện điều đó từ OpenShift Web Terminal. Bạn có thể xem kết quả trong Hình 4.

VSCODE_SAMPLE_DW="https://eclipse-che.github.io/che-devfile-registry/main/devfiles/nodejs/devworkspace-che-code-insiders.yaml"
 
curl  -sSL "${VSCODE_SAMPLE_DW}" | sed 's/^[[:space:]]\{8,\}container:/        container:^          env: [{name: CODE_HOST, value: "0.0.0.0"}]/g' | # <-- CHE IS NOT THERE
sed 's/template:/template:^    attributes:^      controller.devfile.io\/storage-type: ephemeral/g' | # <-- EPHEMERAL IS FASTER
sed 's/volume: {}/volume: {ephemeral: true}/g' |
sed '/tkn=eclipse-che/d' |
tr '^' '\n' | \
oc apply -f -
oc get dw nodejs-web-app --watch

Chạy mã Visual Studio trong Red Hat Developer Sandbox bằng DevWorkspace Operator

Hình 4: Chạy Visual Studio Code trong Red Hat Developer Sandbox bằng DevWorkspace Operator

Chúng tôi vẫn đang nỗ lực mở rộng hỗ trợ trình chỉnh sửa trong OpenShift Dev Spaces. Nhưng bằng cách làm theo các bước được nêu ở đây, người dùng có thể tận dụng sự quen thuộc của họ với Visual Studio Code và hệ sinh thái các tiện ích mở rộng của nó ngay hôm nay.

Đặc biệt cảm ơn Rick Wagner và Florent Benoit đã đánh giá và góp ý cho bài viết này.

Liên kết: https://developers.redhat.com/articles/2022/07/12/how-run-vs-code-openshift-dev-spaces#is_it_possible_to_use_visual_studio_code_on_the_developer_sandbox_

#visualstudiocode #openshift 

Cách Chạy Mã VS Với OpenShift Dev Spaces

Efficient Selenium Protocol Implementas Run Everything in Kubernetes

Moon

Moon is a commercial closed-source enterprise Selenium implementation using Kubernetes to launch browsers.

Moon Animation

Pricing Model

  • The only limitation that determines final Moon price is the total number of browser pods being run in parallel.
  • You can run up to 4 (four) parallel pods for free. Everything on top of free limit is paid as a subscription.
  • Detailed pricing information is available in respective documentation section.
  • To obtain a free evaluation license key email to sales@aerokube.com

Free Support

Features

The main idea behind Moon is to be easily installable and require zero maintenance.

One-command Installation

Having a running Kubernetes cluster and kubectl pointing to it you can launch free Moon cluster with this one-liner:

$ git clone https://github.com/aerokube/moon-deploy.git && cd moon-deploy && kubectl apply -f moon.yaml

To obtain Moon load balancer IP address use the following command:

$ kubectl get svc -n moon
NAME      TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)                         AGE
moon      LoadBalancer   10.63.242.109   104.154.161.58   4444:31894/TCP,8080:30625/TCP   1m

Now use the following Selenium URL in your code:

http://104.154.161.58:4444/wd/hub

We also provide detailed installation video.

Automatic Browser Management

Browsers

  • We maintain ready to use images for Firefox, Chrome, Opera and Android.
  • New browser versions are automatically accessible right after releases.

Scalability and Fault Tolerance

  • Your cluster size is automatically determined by Kubernetes depending on the load.
  • Moon is completely stateless and allows to run an unlimited number of replicas behind load balancer.
  • No additional configuration is required to add a new Moon replica.
  • User requests are not lost even in case of an accidental crash or downtime of the replica.

Efficient and Lightning Fast

  • Completely new Selenium protocol implementation using lightning fast Golang.
  • One Moon replica consumes 0.5 CPU and 512 Mb RAM maximum.
  • One Moon replica is able to work with thousands of running sessions.
  • No Selenium Grid components used.

Logs and Video

  • You can access live browser screen and logs for debugging purposes during test run.
  • Any browser session can be saved to a video file using desired codec, frame rate and screen size.
  • Logs and video files can be automatically uploaded to S3-compatible storage.

Complete Guide

Complete reference guide can be found at: http://aerokube.com/moon/latest/

Author: Aerokube
Source Code: https://github.com/aerokube/moon 
License: Apache-2.0 license

#node #selenium #kubernetes #openshift #playwright 

Efficient Selenium Protocol Implementas Run Everything in Kubernetes
Vinnie  Erdman

Vinnie Erdman

1654031160

How to Get Started With OpenShift CLI (OC CLI)

In this video, you'll learn about:
- OpenShift CLI commands
- Creating resources OC CLI
- Retrieving resources with OC CLI

#devops  #openshift  #kubernetes 

How to Get Started With OpenShift CLI (OC CLI)