Cet article a été publié pour la première fois sur le compte public de la communauté Nebula Graph
Solutions
Le moyen le plus pratique de résoudre le problème de ne pas pouvoir se connecter au cluster après que K8s ait déployé le cluster Nebula Graph consiste à exécuter nebula-algorithm / nebula-spark dans le même espace de noms réseau que nebula-operator show hosts metaet 域名:端口à remplir l'adresse dans format MetaD dans la configuration. .
Remarque : La version 2.6.2 ou ultérieure est requise ici, nebula-spark-connector / nebula-algorithm ne prend en charge que les adresses MetaD sous la forme de noms de domaine.
Voici la configuration réseau réelle :
- Obtenir l'adresse MetaD
(root@nebula) [(none)]> show hosts meta
+------------------------------------------------------------------+------+----------+--------+--------------+---------+
| Host | Port | Status | Role | Git Info Sha | Version |
+------------------------------------------------------------------+------+----------+--------+--------------+---------+
| "nebula-metad-0.nebula-metad-headless.default.svc.cluster.local" | 9559 | "ONLINE" | "META" | "d113f4a" | "2.6.2" |
+------------------------------------------------------------------+------+----------+--------+--------------+---------+
Got 1 rows (time spent 1378/2598 us)
Mon, 14 Feb 2022 08:22:33 UTC
Le nom d'hôte doit être enregistré ici afin qu'il puisse être utilisé dans les fichiers de configuration ultérieurs.
- Remplissez le fichier de configuration de nebula-algorithm
Reportez-vous à la documentation https://github.com/vesoft-inc/nebula-algorithm/blob/master/nebula-algorithm/src/main/resources/application.conf . Il existe deux manières de remplir le fichier de configuration : modifier le fichier TOML ou ajouter des informations de configuration dans le code nebula-spark-connector.
Méthode 1 : modifier le fichier TOML
# ...
nebula: {
# algo's data source from Nebula. If data.source is nebula, then this nebula.read config can be valid.
read: {
# 这里填上刚获得到的 meta 的 Host 名，多个地址的话用英文字符下的逗号隔开；
metaAddress: "nebula-metad-0.nebula-metad-headless.default.svc.cluster.local:9559"
#...
Méthode 2 : appeler le code de nebula-spark-connector
val config = NebulaConnectionConfig
.builder()
// 这里填上刚获得到的 meta 的 Host 名
.withMetaAddress("nebula-metad-0.nebula-metad-headless.default.svc.cluster.local:9559")
.withConenctionRetry(2)
.build()
val nebulaReadVertexConfig: ReadNebulaConfig = ReadNebulaConfig
.builder()
.withSpace("foo_bar_space")
.withLabel("person")
.withNoColumn(false)
.withReturnCols(List("birthday"))
.withLimit(10)
.withPartitionNum(10)
.build()
val vertex = spark.read.nebula(config, nebulaReadVertexConfig).loadVerticesToDF()
Ok, jusqu'à présent, le processus semble assez simple. Alors pourquoi un processus aussi simple vaut-il un article ?
Les informations de configuration sont faciles à ignorer
Nous venons de parler de l'opération pratique spécifique, mais il y a quelques connaissances théoriques ici :
a. MetaD doit implicitement s'assurer que l'adresse de StorageD est accessible à l'environnement Spark ;
b. L'adresse StorageD est obtenue à partir de MetaD ;
c. Dans l'opérateur Nebula K8s, la source de l'adresse StorageD (découverte de service) stockée dans MetaD est le fichier de configuration StorageD, qui est l'adresse interne de K8s.
connaissances de base
La raison de a. est relativement simple et est liée à l'architecture de Nebula : les données du graphe sont stockées dans le service de stockage. Habituellement, la requête de l'instruction est transmise de manière transparente via le service de graphe. Seule la connexion de GraphD est assez, et nebula-spark- Le scénario dans lequel le connecteur utilise Nebula Graph consiste à analyser le graphe ou le sous-graphe complet. À ce stade, la conception de la séparation de l'informatique et du stockage nous permet de contourner la requête et la couche informatique pour lire directement et efficacement données graphiques.
La question est donc de savoir pourquoi avez-vous besoin et n'avez-vous besoin que de l'adresse MetaD ?
Ceci est également lié à l'architecture. Le Meta Service contient les données distribuées du graphe complet et la distribution de chaque shard et instance du Service de Stockage distribué, donc d'une part, seul le Meta a les informations du graphe complet (requis ), d'autre part Parce que cette partie de l'information (uniquement) peut être obtenue auprès de Meta. Voici la réponse pour b .
- Les informations détaillées sur l'architecture Nebula Graph peuvent faire référence à la série de trilogies d'architecture
- La conception globale de l'architecture de la base de données de graphes de la série d'analyse d'architecture Nebula (zéro)
- Nebula Architecture Analysis Series (1) Conception de stockage de la base de données de graphes
- Nebula Architecture Analysis Series (2) Conception du moteur de requête de la base de données de graphes
Jetons un coup d'œil à la logique derrière c.
c. Dans Nebula K8s Operator, la source de l'adresse StorageD (découverte de service) stockée dans MetaD est le fichier de configuration StorageD, qui est l'adresse interne de k8s.
Ceci est lié au mécanisme de découverte de service dans Nebula Graph : dans le cluster Nebula Graph, le service Graph et le service de stockage rapportent leurs informations au méta-service via un battement de cœur, et la source de la propre adresse du service provient de leur correspondant. Le réseau configuration dans le fichier de configuration.
-
Pour la configuration de l'adresse du service lui-même, veuillez vous référer au document : Configuration du réseau de stockage
-
Pour des informations détaillées sur la découverte de service, veuillez vous référer à l'article de Four Kings: Graph Database Nebula Graph Cluster Communication: Starting with Heartbeat .
Enfin, nous savons que Nebula Operator est une application qui crée, maintient et met à l'échelle automatiquement le plan de contrôle K8s du cluster Nebula en fonction de la configuration dans le cluster K8s. Il a besoin d'abstraire certaines configurations internes liées aux ressources, y compris GraphD et Instances StorageD. Les adresses réelles avec lesquelles elles sont configurées sont en fait des adresses de service sans tête .
Ces adresses (comme suit) ne sont pas accessibles par le réseau externe de K8 par défaut, donc pour GraphD et MetaD, nous pouvons facilement créer des services pour les exposer.
(root@nebula) [(none)]> show hosts meta
+------------------------------------------------------------------+------+----------+--------+--------------+---------+
| Host | Port | Status | Role | Git Info Sha | Version |
+------------------------------------------------------------------+------+----------+--------+--------------+---------+
| "nebula-metad-0.nebula-metad-headless.default.svc.cluster.local" | 9559 | "ONLINE" | "META" | "d113f4a" | "2.6.2" |
+------------------------------------------------------------------+------+----------+--------+--------------+---------+
Got 1 rows (time spent 1378/2598 us)
Mon, 14 Feb 2022 09:22:33 UTC
(root@nebula) [(none)]> show hosts graph
+---------------------------------------------------------------+------+----------+---------+--------------+---------+
| Host | Port | Status | Role | Git Info Sha | Version |
+---------------------------------------------------------------+------+----------+---------+--------------+---------+
| "nebula-graphd-0.nebula-graphd-svc.default.svc.cluster.local" | 9669 | "ONLINE" | "GRAPH" | "d113f4a" | "2.6.2" |
+---------------------------------------------------------------+------+----------+---------+--------------+---------+
Got 1 rows (time spent 2072/3403 us)
Mon, 14 Feb 2022 10:03:58 UTC
(root@nebula) [(none)]> show hosts storage
+------------------------------------------------------------------------+------+----------+-----------+--------------+---------+
| Host | Port | Status | Role | Git Info Sha | Version |
+------------------------------------------------------------------------+------+----------+-----------+--------------+---------+
| "nebula-storaged-0.nebula-storaged-headless.default.svc.cluster.local" | 9779 | "ONLINE" | "STORAGE" | "d113f4a" | "2.6.2" |
| "nebula-storaged-1.nebula-storaged-headless.default.svc.cluster.local" | 9779 | "ONLINE" | "STORAGE" | "d113f4a" | "2.6.2" |
| "nebula-storaged-2.nebula-storaged-headless.default.svc.cluster.local" | 9779 | "ONLINE" | "STORAGE" | "d113f4a" | "2.6.2" |
+------------------------------------------------------------------------+------+----------+-----------+--------------+---------+
Got 3 rows (time spent 1603/2979 us)
Mon, 14 Feb 2022 10:05:24 UTC
Cependant, étant donné que le nebula-spark-connector susmentionné obtient l'adresse de StorageD via Meta Service, et que cette adresse est découverte par le service, l'adresse StorageD réellement obtenue par nebula-spark-connector est le service sans adresse ci-dessus, qui ne peut pas être accessible directement de l'extérieur.
Par conséquent, si nous avons les conditions, nous n'avons qu'à laisser Spark fonctionner dans le même réseau K8s que Nebula Cluster, et tout sera résolu.
-
Exposez les adresses L4 (TCP) de MetaD et StorageD via Ingress.
Vous pouvez vous référer à la documentation de Nebula Operator : https://github.com/vesoft-inc/nebula-operator
-
Ces services sans tête peuvent être résolus vers le StorageD correspondant via un proxy inverse et un DNS.
Alors, y a-t-il un moyen plus pratique ?
Malheureusement, le moyen le plus pratique reste celui décrit au début de l'article : laissez Spark s'exécuter à l'intérieur de l'amas de nébuleuses. En fait, j'essaie de pousser la communauté Nebula Spark à prendre en charge l'option configurable StorageAddresses, et avec elle, le 2. susmentionné est inutile.
Algorithme de nébuleuse + expérience d'opérateur de nébuleuse plus pratique
Afin de faciliter les étudiants qui sont les premiers à adopter le graphe de nébuleuse et l'algorithme de nébuleuse sur les K8, voici un petit outil Neubla-Operator-KinD écrit par Amway lui-même Opérateur et toutes les dépendances (y compris le fournisseur de stockage) widgets. Non seulement cela, mais il déploie automatiquement un petit cluster Nebula. Vous pouvez voir les étapes ci-dessous :
La première étape consiste à déployer K8s + nebula-operator + Nebula Cluster :
curl -sL nebula-kind.siwei.io/install.sh | bash
La deuxième étape, suivez la suite dans la documentation de l'outil
a. Utilisez la console pour vous connecter au cluster et charger l'exemple d'ensemble de données
b. Exécutez un algorithme de graphe dans ce K8s
- Créer un environnement Spark
kubectl create -f http://nebula-kind.siwei.io/deployment/spark.yaml
kubectl wait pod --timeout=-1s --for=condition=Ready -l '!job-name'
- Une fois que les attentes ci-dessus sont prêtes, entrez dans la nacelle d'allumage.
kubectl exec -it deploy/spark-deployment -- bash
- Téléchargez nebula-algorithm tel que
2.6.2cette version. Pour plus de versions, veuillez vous référer à https://github.com/vesoft-inc/nebula-algorithm/.
Précautions:
- La version officielle est disponible ici : https://repo1.maven.org/maven2/com/vesoft/nebula-algorithm/
- En raison de ce problème : https://github.com/vesoft-inc/nebula-algorithm/issues/42
2.6.2Seules les versions plus récentes prennent en charge l'accès au nom de domaine à MetaD.
# 下载 nebula-algorithm-2.6.2.jar
wget https://repo1.maven.org/maven2/com/vesoft/nebula-algorithm/2.6.2/nebula-algorithm-2.6.2.jar
# 下载 nebula-algorthm 配置文件
wget https://github.com/vesoft-inc/nebula-algorithm/raw/v2.6/nebula-algorithm/src/main/resources/application.conf
- Modifiez les informations d'adresse de mètre et de graphique dans l'algorithme de nébuleuse.
sed -i '/^ metaAddress/c\ metaAddress: \"nebula-metad-0.nebula-metad-headless.default.svc.cluster.local:9559\"' application.conf
sed -i '/^ graphAddress/c\ graphAddress: \"nebula-graphd-0.nebula-graphd-svc.default.svc.cluster.local:9669\"' application.conf
##### change space
sed -i '/^ space/c\ space: basketballplayer' application.conf
##### read data from nebula graph
sed -i '/^ source/c\ source: nebula' application.conf
##### execute algorithm: labelpropagation
sed -i '/^ executeAlgo/c\ executeAlgo: labelpropagation' application.conf
- Exécuter l'algorithme LPA dans l'espace graphique du joueur de basket-ball
/spark/bin/spark-submit --master "local" --conf spark.rpc.askTimeout=6000s \
--class com.vesoft.nebula.algorithm.Main \
nebula-algorithm-2.6.2.jar \
-p application.conf
- Le résultat est le suivant :
bash-5.0# ls /tmp/count/
_SUCCESS part-00000-5475f9f4-66b9-426b-b0c2-704f946e54d3-c000.csv
bash-5.0# head /tmp/count/part-00000-5475f9f4-66b9-426b-b0c2-704f946e54d3-c000.csv
_id,lpa
1100,1104
2200,2200
2201,2201
1101,1104
2202,2202
Ensuite, vous pouvez Happy Graphing!
Technologie de base de données graphique d'échange ? Pour rejoindre le groupe d'échange Nebula, veuillez d'abord remplir votre carte de visite Nebula , et l'assistant Nebula vous attirera dans le groupe ~~