NebulaGraph VEditor is a high-performance, highly customizable WYSIWYG visualization editing front-end library. NebulaGraph VEditor is based on SVG drawing, and it is easy to develop and customize the drawing by reasonably abstracting the code structure. It is extremely suitable for WYSIWYG editing and preview scenarios such as approval flow, workflow, kinship, ETL processing, and graph query. You can use VEditor to visually query, edit, and model graphs. 

After continuous iterations and polishing, VEditor has been relatively perfect and now its code has been open-sourced. In this topic, I'd like to share some ideas and thoughts about its design.

# Basic Features

- Customizable node and edge styles.
- Flat, simple, and clear code structure.
- Small map and magnetic lines.
- Shortcuts for common operations.
- History management.
- Lightweight, only 160 KB in size before compression.

# Design Ideas


When I first came across the graph editor library, I just wanted to find one for customization and animation. After using many flowchart libraries, I found that most of the designs have bloated interfaces and complex classes. As a front-end developer, it was against my philosophy of writing simple, streamlined, and low-coupling code. So I decided to write a lightweight library myself to meet my needs.

The design concept of VEditor is to make it lighter for developers to use, reduce learning APIs, and reduce reliance on various libraries based on customizability and comprehensibility.

# Architecture

![](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/VEditor/1.png)

The overall architecture is mainly through events to do the dependency management between entities, it is also recommended to get the state changes of the whole flowchart mainly through events.

Among them, the rendering process is semi-automatic rendering, and the rendering needs to be triggered manually after changing the flowchart data. Other state operations on the canvas will trigger the user-defined shape-rendering function to render nodes and lines. 

# Rendering Process

VEditor uses SVG to render the canvas. The declarative use of SVG makes the internal structure visible externally, which is convenient for developers to customize the rendering. Users can directly rewrite the relevant SVG styles outside and can directly use the SVG DOM (Document Object Model) to manipulate mouse events and animate nodes.

In terms of shape rendering, user-defined rendering functions are registered mainly through the exposed Shape interface. From this perspective, VEditor can perform rendering based on any rendering technique, as long as the rendering interface returns an SVGDOM, which can be an SVGElement or ForeignObject. I highly recommend managing SVC rendering through the DOM framework, such as React and Vue. In some cases, you can even wrap a Canvas to render WebGL nodes, which greatly extends the customizability.

In addition to nodes, node anchors and lines also support the object rendering after the corresponding interface is registered as Shape. In actual business scenarios, we use this feature to implement dynamic addition, deletion, and change of algorithm parameter anchors, the input and output anchors of OLTP queries (figure 1), filtering of edges in graph visualization, and step rendering (figure 2). You are welcome to apply for Explorer free trial. Just click [here](https://nebula-graph.com.cn/products/explorer/).

![](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/VEditor/2.png)

![](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/VEditor/3.png)

# Data Structure Design

The data structure of VEditor is similar to most libraries, but it will not destroy the user's object reference, that is, when the user mounts the relevant data to the node or line object, it will be aligned and reserved, so that it will be convenient for the user to mount the relevant data to vertices after vertices or edges are configured. Therefore, the Redo, Undo, etc. operations of the history will store the user's data as snapshots.

# Performance Design

It is well known that SVG has a much worse performance than Canvas for rendering at small resolutions, which is a disadvantage that comes with increased ease of use. This is especially obvious when initializing a large number of more complex or animated nodes. To address this situation, the data rendering part of VEditor uses an asynchronous process, putting the rendering of anchors into the next event loop to avoid the browser-forced redrawing caused by the large number of bounding boxes fetched during the synchronization process. After the drawing is finished, the corresponding nodes are cached to avoid repeated fetching.

When adding nodes or lines, the DOM feature of SVG will let the browser do dirty rendering automatically, so the performance of incremental rendering is not much different from Canvas, but mainly slower when interacting and animating, which leads to a lot of DOM redrawing. The current design performance target is 1000 nodes with complex shapes for smooth rendering, which is easy to achieve in flowchart editing scenarios.

![](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/VEditor/4.jpeg)


# Interaction Design

VEdtior provides Dagre-based directed graph layouts by default. It automatically centers all nodes after Dagre is optimized and called. At the same time, it provides an adaptive size function. Unlike other libraries, the coordinates of the current nodes will be reset to the adaptive position, and the adaptive position can be restored directly after the user saves the current data.

VEditor's mini-map adopts canvg rendering, which directly converts SVG to Canvas, which can guarantee the accuracy of mini-map and reduce the performance loss at the same time. In terms of interaction, VEditor allows you to zoom in and out of the canvas, and drag and drop elements.

# Future Plans

VEditor is expected to be a data editor and renderer for any field by expanding the scenarios where it can be used. In addition, we will continue to improve the performance and user experience of VEditor while supporting the following features in the future. 

- Box selector and multi-select operations.

- Undirected graphs and double arrows

- Further performance optimizations

👉 GitHub open source address: [https://github.com/vesoft-inc/nebulagraph-veditor](https://github.com/vesoft-inc/nebulagraph-veditor)

# You Might Also Like
[Graph Database Visualization: NebulaGraph Explorer](https://www.nebula-graph.io/products/explorer)


NebulaGraph VEditor is a high-performance, highly customizable WYSIWYG visualization editing front-end library.

Meet NebulaGraph VEditor, an Open-Source Graph Editing Library

NebulaGraph is now a mature product with many ecosystem tools. It offers a wide range of options in terms of data import. There is the large and comprehensive Nebula Exchange, the small and compact Nebula Importer, and the Nebula Spark Connector and Nebula Flink Connector for Spark and Flink integrations.

But which of the many import methods is more convenient?

Here are my takes:

**Nebula Exchange**

*   If you need to import streaming data from Kafka and Pulsar into the NebulaGraph database
*   If you need to read batch data from relational databases (e.g. MySQL) or distributed file systems (e.g. HDFS)
*   If you need to generate SST files recognized by NebulaGraph from large batches of data

**Nebula Importer**

*   Nebula Importer is best for importing local CSV files into NebulaGraph

**Nebula Spark Connector:**

*   Migrate data between different NebulaGraph clusters
*   Migrate data between different graph spaces within the same NebulaGraph cluster
*   Migrate data between NebulaGraph and other data sources
*   Combining Nebula Algorithm for graph computation

For more options about how to import data from Spack, read: [4 different ways to work with NebulaGraph in Apache Spark](https://nebula-graph.io/posts/work-with-nebula-graph-apache-spark)

**Nebula Flink Connector**

*   Migrate data between different NebulaGraph clusters
*   Migrate data between different graph spaces within the same NebulaGraph cluster
*   Migrate data between NebulaGraph and other data sources

Overall, Nebula Exchange is large and comprehensive, and can be combined with most storage engines to import into Nebula, but requires a Spark environment to be deployed.

Nebula Importer is simple to use and requires fewer dependencies, but you need to generate your own data file in advance and configure the schema once and for all, but it does not support breakpoint transfer and is suitable for medium data volume.

Spark / Flink Connector needs to be combined with stream batch data.

Choose different tools for different scenarios. For newcomers to Nebula, it is recommended to use Nebula Importer, a data import tool, because it is easy to use and quick to get started.

## Using Nebula Importer

When we first came across NebulaGraph, because the ecology was not perfect, and only some businesses migrated to Nebula, we used to import [NebulaGraph ](https://nebula-graph.io)data, whether full or incremental, by pushing Hive tables to Kafka and consuming Kafka to write NebulaGraph in batch. Later, as more and more data and businesses switched to NebulaGraph, the problem of importing data efficiency became more and more serious. The increase in import time made it unacceptable to still be importing data at full volume during peak business hours.

For the above problems, after trying Nebula Spark Connector and Nebula Importer, we decided to use _Hive table → CSV → Nebula Server → Nebula Importer_ to import the full amount of data for the sake of easy maintenance and migration, and the overall time spent was significantly reduced. The overall time consumption is significantly reduced.

## Configuring Nebula Importer

**System environment**

```
[root@nebula-server-prod-05 importer]# lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                16
On-line CPU(s) list:   0-15
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             1
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 85
Model name:            Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz
Stepping:              7
CPU MHz:               2499.998
BogoMIPS:              4999.99
Hypervisor vendor:     KVM
Virtualization type:   full
L1d cache:             32K
L1i cache:             32K
L2 cache:              1024K
L3 cache:              36608K
NUMA node0 CPU(s):     0-15
```


```
Disk：SSD
Memory: 128G
```

**Cluster Environment**

```
NebulaGraph Version: v2.6.1
Deployment Method: RPM
Cluster size: 3 replicas, 6 nodes
```

**Data Size**
```
+---------+--------------------------+-----------+
| "Space" | "vertices"               | 559191827 |
+---------+--------------------------+-----------+
| "Space" | "edges"                  | 722490436 |
+---------+--------------------------+-----------+

```

**Nebula Importer configuration**


```
# Graph version, set to v2 when connecting 2.x.
version: v2
description: Relation Space import data
# Whether to remove temporarily generated log and error data files.
removeTempFiles: false
clientSettings:
  # The number of retries for failed nGQL statement execution.
  retry: 3
  # Number of concurrency for NebulaGraph clients.
  concurrency: 5
  # The size of the cache queue for each NebulaGraph client.
  channelBufferSize: 1024
  # The NebulaGraph graph space to import data into.
  space: Relation
  # Connection information.
  connection:
    user: root
    password: ******
    address: 10.0.XXX.XXX:9669,10.0.XXX.XXX:9669
  postStart:
    # Configure some actions to be performed before inserting data after connecting to the NebulaGraph server.
    commands: |
    # The interval between the execution of the above commands and the execution of the insert data command.
    afterPeriod: 1s
  preStop:
    # Configure some actions to be performed before disconnecting from the NebulaGraph server.
    commands: |
# The path to the file where log messages such as errors will be output.    
logPath: /mnt/csv_file/prod_relation/err/test.log
....
```

Set up the Crontab, Hive generates the tables and transfers them to the NebulaGraph Server, running Nebula Importer tasks at night when traffic is low:


```
50 03 15 * * /mnt/csv_file/importer/nebula-importer -config /mnt/csv_file/importer/rel.yaml >> /root/rel.log
```
In total, it took 2 hours to complete the import of the full amount of data at 6 am.

Some of the logs are as follows, and the import speed is maintained at a maximum of about 200000/s


```
2022/05/15 03:50:11 [INFO] statsmgr.go:62: Tick: Time(10.00s), Finished(1952500), Failed(0), Read Failed(0), Latency AVG(4232us), Batches Req AVG(4582us), Rows AVG(195248.59/s)
2022/05/15 03:50:16 [INFO] statsmgr.go:62: Tick: Time(15.00s), Finished(2925600), Failed(0), Read Failed(0), Latency AVG(4421us), Batches Req AVG(4761us), Rows AVG(195039.12/s)
2022/05/15 03:50:21 [INFO] statsmgr.go:62: Tick: Time(20.00s), Finished(3927400), Failed(0), Read Failed(0), Latency AVG(4486us), Batches Req AVG(4818us), Rows AVG(196367.10/s)
2022/05/15 03:50:26 [INFO] statsmgr.go:62: Tick: Time(25.00s), Finished(5140500), Failed(0), Read Failed(0), Latency AVG(4327us), Batches Req AVG(4653us), Rows AVG(205619.44/s)
2022/05/15 03:50:31 [INFO] statsmgr.go:62: Tick: Time(30.00s), Finished(6080800), Failed(0), Read Failed(0), Latency AVG(4431us), Batches Req AVG(4755us), Rows AVG(202693.39/s)
2022/05/15 03:50:36 [INFO] statsmgr.go:62: Tick: Time(35.00s), Finished(7087200), Failed(0), Read Failed(0), Latency AVG(4461us), Batches Req AVG(4784us), Rows AVG(202489.00/s)
```

Then at 7:00, Kafka is re-consumed to import the incremental data from the early morning of the day to 7:00 based on the timestamp, preventing the full amount of t+1 data from overwriting the incremental data of the day.

The incremental consumption takes about 10-15 min.

## Real-time

The incremental data obtained from the MD5 comparison is imported into Kafka, and Kafka data is consumed in real-time to ensure that the data delay is no more than 1 minute.

In addition, there may be unanticipated data issues that are not detected in real-time for a long time, so the full amount of data is imported every 30 days, which is the Nebula Importer import described above. Then add a_ TTL=35 days _to the point side of Space to ensure that any data not updated in time will be filtered and subsequently recycled.

## About the author

Reid is an engineer at Qichacha, China’s biggest corporate information platform.

Nebula Importer is simple to use and requires fewer dependencies, but you need to generate your own data file in advance and configure the schema once and for all, but it does not support breakpoint transfer and is suitable for medium data volume.

Importing data into NebulaGraph using Nebula Importer


![NebulaGraph Cloud is live on the Azure marketplace](https://user-images.githubusercontent.com/90186547/158126069-7b936ffd-0ed5-46eb-ad5e-4c6b4a131545.jpg)

We are thrilled to announce that NebulaGraph’s first cloud offering, NebulaGraph Cloud, is now available on the Microsoft Azure marketplace. Simply subscribe to the NebulaGraph Cloud service on the Azure marketplace for free and you can have a NebulaGraph cluster up and running in a matter of minutes.

NebulaGraph Cloud is a graph database as a service in the cloud that enables you to deploy NebulaGraph clusters without the hassle of managing infrastructure. The service is only available on the Azure cloud platform at the moment, but we already have plans to support other cloud vendors like Amazon Web Service (AWS) and Google Cloud Platform (GCP).

NebulaGraph is currently in public beta and it offers a generous discount of 70% off. The service provides an on-demand pricing model, which charges only for compute capacity and storage usage. With the 70% discount, you can set up a NebulaGraph cluster for as low as $0.35 per hour.

With NebulaGraph Cloud, you can create a graph database within minutes, and quickly expand computing and storage. It is also integrated with a wide range of Nebula visualization tools, including Nebula Dashboard and Nebula Explorer, which allow you to manage your clusters or play with your graph data in a web user interface. 

![NebulaGraph Cloud is now available on the Azure marketplace](https://user-images.githubusercontent.com/90186547/157793364-6cc9a797-7e98-4ef8-adc2-b2b7793f6987.png)

# Features

* ### Pay for what you use

With per-hour billing, you only pay for what you use. NebulaGraph Cloud allows you to choose different instance types and storage spaces for the Storage Engine and Query Engine upon creating the cluster. You can increase or decrease your compute capacity to meet the demands of your application and only pay for the instance you use.

![Pay for what you use](https://user-images.githubusercontent.com/90186547/157793532-53baf88d-9448-4245-acb3-873bbd1efc9c.png)

* ### A secure and intuitive management panel

NebulaGraph Cloud comes with an intuitive management panel that allows you to view your subscription information and logs, stop or transfer solutions (solution refers to the NebulaGraph database running on NebulaGraph Cloud), or scale in and out your cluster. The panel also supports a fine-grained access control. You can add database users with different role privileges to specific graph spaces to ensure your data security.

![A secure and intuitive management panel](https://user-images.githubusercontent.com/90186547/157793610-93592028-f61f-46d1-bd31-d157dda8abbd.png)

![A secure and intuitive management panel](https://user-images.githubusercontent.com/90186547/157793659-1bf2cad1-4452-4b87-9880-019f2a3af84a.png)

* ### Seamless visualization integrations

NebulaGraph Cloud offers an end-to-end solution: a distributed and extensible graph database, sophisticated tools to manage data, and efficient dashboards to import graph data and run queries. It comes with Nebula Studio, Nebula Explorer, and Nebula Dashboard. You can use them to easily import, explore and analysis your graph data, and manage your graph database clusters, bringing you a seamless cloud experience.

![Seamless visualization integrations](https://user-images.githubusercontent.com/90186547/157793723-59b536e5-ade4-4b18-b51a-0970816d295e.png)

![Seamless visualization integrations](https://user-images.githubusercontent.com/90186547/157793762-b91c131e-53d2-4645-b608-722ab67b11ff.png)

![Seamless visualization integrations](https://user-images.githubusercontent.com/90186547/157793807-b640fbfa-b912-4413-be88-d66d22a420bb.png)

* ### High availability and premium support

NebulaGraph clusters use Raft to implement data redundancy backup with multi-data center deployment to ensure the integrity of data, and the high availability of the cloud computing infrastructure and cloud servers. If you encounter any problems during use, you can quickly create a work order on your cloud management panel and a technical support specialist will help you solve your problem as soon as possible.

![High availability and premium support](https://user-images.githubusercontent.com/90186547/157793861-0810129e-b662-45a2-bf0d-4183662c2ada.png)

# Lock in your beta pricing

You can now enjoy an exclusive discount of **70% OFF** during the public beta( from February 10, 2022 to March 31, 2022 ), with the lowest configuration price being about $0.35/hour!

The good news is that all beta users will enjoy the discounted pricing forever, even after the beta!

![Lock in your beta pricing](https://user-images.githubusercontent.com/90186547/157793938-9929805a-8612-494e-b0e7-21b74a8e19d5.png)

This picture provides an overview of different instance types and the pricing. For more details about all plans and prices, please visit our [Azure marketplace lising page](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/vesoftcompanylimited1625556994617.nebula_graph_cloud?tab=PlansAndPrice).

# How can I get started?

Step 1: In [Azure Marketplace](https://portal.azure.com/?l=en.en-us#blade/Microsoft_Azure_Marketplace/GalleryMenuBlade/selectedMenuItemId/home), search for NebulaGraph Cloud in the search bar on the top, and you will see [NebulaGraph Cloud](https://portal.azure.com/#create/vesoftcompanylimited1625556994617.nebula_graph_cloud/preview) showing in the results. Or you can directly click NebulaGraph Cloud to enter the subscription page.

Step 2: Select a configuration according to your own needs and click **Set up + subscribe**.

For details, please see our docs: https://docs.nebula-graph.io/2.6.2/nebula-cloud/1.what-is-cloud/

If you have anything questions, please start a discussion via [Slack](https://app.slack.com/client/TJB3N2BPD/CJNFUM7AR) or email [inquiry@vesoft.com](inquiry@vesoft.com) to talk to our cloud specialists.

NebulaGraph Cloud is live on the Azure marketplace now! It is a cloud service for NebulaGraph that can quickly expand computing, storage and other resources. In Beta, a special 70% off discount is offered for new customers.

NebulaGraph Cloud is now available on the Azure marketplace, our first cloud offering


![Introducing Nebula Dashboard: The brain of your NebulaGraph cluster](https://user-images.githubusercontent.com/90186547/155935795-eaf86ef4-be5e-4e95-a81d-93298ab2526c.jpg)

Distributed database systems like NebulaGraph perform well in storing data but they make DevOps difficult and complicated. Building and managing clusters is pain and time-consuming. Not to mention it is not easy to back up and upgrade the system, especially in the production environment.

Introducing [Nebula Dashboard](https://nebula-graph.io/products/dashboard/), a visualization tool that helps you manage your NebulaGraph clusters in an intuitive web user interface. Nebula Dashboard can help DevOps engineers and database administrators (DBAs) reduce the daily cost of managing a NebulaGraph cluster and ensure the stability of their systems.

If you want a free trial of Nebula Dashboard enterprise edition, click here: https://dashboard.nebula-graph.io/

# The structure
The following figure gives the six main features of Nebula Dashboard. They are cluster management, monitoring, alarming, single cluster configuration, access control, and system setting. 

![Nebula Dashboard Structure](https://user-images.githubusercontent.com/90186547/155936570-00156e85-fc82-4792-b638-d5cc7fc98287.png)

# The one dashboard to rule them all

First, let's dive into the main features of Nebula Dashboard: multi-cluster orchestration & lifecycle management, monitoring and alerting, and access control.

## Multi-cluster orchestration & lifecycle management

The lifecycle for a NebulaGraph cluster refers to the journey from the creation of a cluster to management to eventual recycling.

![Nebula Dashboard rules all](https://user-images.githubusercontent.com/90186547/155936823-5cf11b30-f9d3-49d4-a793-f84e14e7451b.png)

Nebula Dashboard can manage the full lifecycle of your NebulaGraph cluster in a visualized way. 

When you have not created a NebulaGraph cluster, Nebula Dashboard enables you to start the creation of a new cluster. If you are already working with NebulaGraph clusters, you can import those clusters into Nebula Dashboard in batch and monitor or manage them there. We will go through the entire process of creating and managing clusters in this chapter.

**Create a cluster from Nebula Dashboard**

![Create a cluster from Nebula Dashboard](https://user-images.githubusercontent.com/90186547/155937028-dbd2ac45-7784-4fa4-b3f8-47774cb89579.png)

There are five steps to create a cluster, as shown in the figure above:

1. Input a unique cluster name

2. Choose the NebulaGraph version that you want to create a cluster. Please note that Nebula Dashboard only supports NebulaGraph v2.0 and above. By default, Nebula Dashboard provides three built-in installation package: v2.6.1, v2.5.1, and v2.0.1. It will also support NebulaGraph v3.0.0 once it is released in mid February 2022.

3. Add nodes to the cluster. You may need to authorize the step from SSH.

4. Select the services to be deployed on different nodes. For simplicity, you can also use the "Auto Add Service” feature to evenly deploy services to different nodes.

5. Confirm everything is OK and click “Create Cluster.” And voilà, you have your NebulaGraph cluster up and running.

**Importing a cluster into Nebula Dashboard**

If you have a NebulaGraph cluster running, you can import it into Nebula Dashboard to manage it in a graphic user interface.

![Importing a cluster into Nebula Dashboard](https://user-images.githubusercontent.com/90186547/155937402-c6c78c8e-6f70-4422-8d6b-dc6616042d27.png)

![Importing a cluster into Nebula Dashboard](https://user-images.githubusercontent.com/90186547/155937479-b1b765e4-ea2a-459a-8053-968f7f2042ed.png)

## Cluster operations and maintenance
Once you have completed the above two steps, you can use Nebula Dashboard to manage your clusters. Cluster management can be tedious. It involves repeated actions such as management of clusters, nodes and services. Nebula Dashboard can free DevOps engineers from this unbearable boredom by simplifying the whole process of cluster management. 

Here are what you can do with Nebula Dashboard to manage your cluster:

**Node and service management**
Nebula Dashboard’s Node management and Service management modules will give you an intuitive overview of all the information about running nodes in the cluster and services in each node.  You can do actions such as adding empty nodes and starting or stopping services in a node.

![Node and service management](https://user-images.githubusercontent.com/90186547/155937599-0fdca548-7df2-46ed-9c87-c8b3be473a3a.png)

![Node and service management](https://user-images.githubusercontent.com/90186547/155938301-68a54552-1dc0-4160-aa03-9756d63c3994.png)

**Be informed. Be alerted.**

Monitoring the health of a cluster is the first priority forNebula Dashboard. Nebula Dashboard provides cluster overview, node metrics monitoring, service metrics monitoring, and alarm notification capabilities to help DevOps engineers stay informed of their NebulaGraph cluster health.

**Cluster overview**

In the overview section, DevOps engineers can quickly understand the overall situation of the current cluster, including the distribution of services in the node, operational status, and customize indicators of their most concerned metrics to stay alarmed.  

![Cluster overview](https://user-images.githubusercontent.com/90186547/155938434-91ac15f9-8652-4020-9cc8-15f1005e2057.png)

**Node monitoring**

Node monitoring is used to present all the information of a particular NebulaGraph node, including its CPU usage, memory, load, and disk. You can also set a baseline for a specific metric so that you can be alerted when the metric exceeds the baseline. 

![Node monitoring](https://user-images.githubusercontent.com/90186547/155938547-adb5798b-bd23-4f32-b989-d5f044b863d4.png)

**Service monitoring**

Service monitoring mainly involves the metrics of three services of NebulaGraph clusters. The three services are graphd, metad and storaged. Currently, Nebula Dashboard can present dozens of cluster metrics and monitor them based on their aggregations and averages. These metrics include the number of slow queries and errors in the graphd service, vertex  and edge latencies of storaged, and heartbeat latencies of the metad service. 

![Service monitoring](https://user-images.githubusercontent.com/90186547/155938646-d1e9741f-1fc8-43ee-9cc0-5bb0a3b06d65.png)

**Alert**

Nebula Dashboard's alert module is a service for alerting the monitoring indicators of NebulaGraph clusters. You can view alert information, set alert rules and alert recipients in the module. 

You can set up alert baselines of indicators that you care about, and the frequency and duration of the alert triggering, as well as the notification message template, so that the system will automatically send out notifications to alert you when any of the indicators triggers the corresponding rules.

You can view history alert messages, in-site alert messages, set up email and webhook notifications, and set alert rules in the alert module. Here is how the module works:

1. Create custom alert rules or activate alert rules.
2. An alert message will be sent when the system monitors any abnormal metric.
3. A pop-up in-site message of the alert is shown on the top right of Nebula Dashboard. The system will send out an alert email if you have set an email recipient.

4. You can then perform troubleshooting based on the alert message.  

![Alert](https://user-images.githubusercontent.com/90186547/155938848-384522e4-3b99-4d50-83ed-7d633143d118.png)

**Fine-grained access control**

As a multi-cluster management tool, Nebula Dashboard has enabled a fine-grained access control system to ensure security.  Nebula Dashboard has designed two roles, and they are admins and users. While admins are authorized to perform overall configuration of the Dashboard, users are only entitled to operate within the scope that is assigned to them.

**LDAP login**

Nebula Dashboard supports login with Lightweight Directory Access Protocol (LDAP). Once the LDAP information is provided in the deployment phase, users can log in with their enterprise account. Admins can invite users by sending them an email containing a verification link.

## Feature roadmap

Nebula Dashboard is designed to simplify the daily tasks of DevOps engineers and database administrators (DBAs). It will support the following features in the forthcoming versions.

Back up and upgrade a cluster with one click. This feature will only be compatible with NebulaGraph v3.0 and above.
Visualized management of Storage Zone
TV dashboard that allows you to display key metrics in a customized way in a display in your office 
Slow query management that allows DBAs to quickly identify slow queries.

# Wanna try?

Check out the Nebula Dashboard playground to see how Nebula Dashboard works in practice..  You can also click this link to request a 15-day free trial to test Nebula Dashboard enterprise edition out in your own environment.

If you encounter any problems in the process of using NebulaGraph, please refer to [NebulaGraph Database Manual](https://docs.nebula-graph.io/3.0.1/pdf/NebulaGraph-EN.pdf) to troubleshoot the problem. It records in detail the knowledge points and specific usage of the graph database and the graph database NebulaGraph.

Join our [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-7ybejuqa-NCZBroh~PCh66d9kOQj45g) if you want to discuss with the rest of the NebulaGraph community!

Nebula Dashboard is a visualization tool that helps you manage your NebulaGraph clusters in an intuitive web user interface.

Introducing Nebula Dashboard: The brain of your NebulaGraph cluster


![nebula-explorer](https://user-images.githubusercontent.com/90186547/139035653-d03f7c75-f6b2-47eb-ac55-a32351c6429d.jpg)

Nebula Explorer is a visualization tool of the NebulaGraph ecosystem. With it, you can easily access NebulaGraph, and then query and retrieve graph data via GUI without having to learn nGQL. It can display graph data as a graph on a canvas for you to visually analyze data. 

# Querying Graph Data

![Querying Graph Data](https://user-images.githubusercontent.com/90186547/139034825-447c58a9-27d8-40fa-84ec-31cb0a018a95.png)

Nebula Explorer provides various methods for querying graph data. For example, you can specify a VID list or tags (with their indexes) to query vertices, or specify one or more VIDs to query a subgraph. When the queried vertices are retrieved, you can select one or more for further exploration. For example, you can query for the shared neighbors and the related paths of each pair of vertices. Through progressive queries, you can improve and enrich the data on the canvas for further graph analysis.

![Querying Graph Data](https://user-images.githubusercontent.com/90186547/139036362-29b7520c-6e59-46b1-8d6a-a9802cadc511.png)

# Displaying Graph Data

When the graph data is retrieved, you can manipulate it on the canvas flexibly, including drag-and-drop, zoom-in or zoom-out, click-and-drag, and marking vertices with colors or icons. Nebula Explorer enables you to have fun with the graph data model by providing various features.

![Displaying Graph Data](https://user-images.githubusercontent.com/90186547/139036868-adcac1fe-8b97-4acb-8e69-25af5a936ace.png)

# Roadmap

Besides querying and exploring data, Nebula Explorer will support graph computing in the future, which will enable the NebulaGraph users to use appropriate methods to query and analyze graph data in various business scenarios.

Currently, Nebula Explorer is only available for Enterprise users. If you are interested, please send an email with "Require Dashboard" as the subject to inquiry@vesoft.com. 


If you encounter any problems in the process of using NebulaGraph, please refer to [NebulaGraph Database Manual](https://docs.nebula-graph.io/2.5.0/pdf/NebulaGraph-EN.pdf) to troubleshoot the problem. It records in detail the knowledge points and specific usage of the graph database and the graph database NebulaGraph.

Join our [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-7ybejuqa-NCZBroh~PCh66d9kOQj45g) if you want to discuss with the rest of the NebulaGraph community!

Nebula Explorer is a visualization tool of the NebulaGraph ecosystem. With it, you can easily access NebulaGraph, and then query and retrieve graph data via GUI without having to learn nGQL.

Visualizing Graph Data with Nebula Explorer

Data is crucial. To ensure the reliability and stability of online services, and thus to ensure data security, you should monitor the hardware resources, performance, and services of the servers, and perform daily statistical analysis. Therefore, once a server fails, you can quickly troubleshoot and resolve failures by viewing the monitoring information.

NebulaGraph Dashboard (Dashboard in short) is a visualization tool that displays information of the machines of a NebulaGraph cluster and its services, which can be used for data analysis and service monitoring. On Dashboard, you can view the metrics of the hardware and the NebulaGraph services on each machine, and analyze and monitor the service status during the specified period. The information helps you manage, operate, and maintain the services better and more visually.

# Machine Monitoring

![nebula-dashboard](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-dashboard-01.png)

On Dashboard, you can monitor and then view the metrics of the machines in a NebulaGraph cluster in a visual way, such as CPU, memory, load, disk usage, and network traffic. 

![nebula-dashboard](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-dashboard-02.png)

On each metric chart, you can view and monitor the metric by filtering the variables. Additionally, Dashboard supports filtering information by specifying periods or cluster nodes. By zooming in or out the view, setting the baseline (for reference), reading the instructions on a metric variable, and so on, you can analyze the monitoring data. 

# Service Monitoring

![nebula-dashboard](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-dashboard-03.png)

The Service module monitors the Graph, Meta, and Storage services of NebulaGraph. By clicking the Overview tab, you can view the number of each service in different statuses, and analyze a service by comparing its two metrics. 

![nebula-dashboard](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-dashboard-04.png)

By clicking the tab for a specific service, Dashboard can display the service details according to the specified metric (variables) or period. Additionally, it supports filtering information by specifying time range, period, or cluster nodes.  

![nebula-dashboard](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-dashboard-05.png)

In the Management tab, you can view the query and partition information of the specified graph space. Besides, this module displays the configurations of each service, such as Storage Service or Graph Service, and the job information. 

# Roadmap

The Dashboard team is focusing on supporting queries for machine and service information by specifying multiple metrics, and also working to enable it to support representing the results graphically and the visual and interactive operations on a drawing board for analyzing metrics. In the future, the team will develop more new features such as setting alarm thresholds for a specified metric.

NebulaGraph Dashboard is open-source, and you can find its source code at https://github.com/vesoft-inc/nebula-dashboard. If you are interested in developing monitoring and visualization tools, and you have some ideas about them, please participate with us as a Dashboard Contributor to build a better monitoring tool. 

If you want to learn more about NebulaGraph, please refer to "NebulaGraph Database Manual" to troubleshoot the problem. It records in detail the knowledge points and specific usage of the graph database and the graph database NebulaGraph.

Here is the Manual link:
[https://docs.nebula-graph.io/2.5.0/pdf/NebulaGraph-EN.pdf](https://docs.nebula-graph.io/2.5.0/pdf/NebulaGraph-EN.pdf)

Join our [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-7ybejuqa-NCZBroh~PCh66d9kOQj45g) if you want to discuss with the rest of the NebulaGraph community!

Data is crucial. To ensure the reliability and stability of online services, and thus to ensure data security, you should monitor the hardware resources, performance, and services of the servers, and perform daily statistical analysis. Therefore, once a server fails, you can quickly troubleshoot and resolve failures by viewing the monitoring information.

Ecosystem Tools: NebulaGraph Dashboard for Monitoring


![Nebula Operator](https://user-images.githubusercontent.com/57335825/126621008-a011782d-98d8-4814-97cd-5a25a07318e7.png)

Hi, everybody! As you know, [Nebula Operator](https://github.com/vesoft-inc/nebula-operator) has been open-source, and we published an [introduction](https://nebula-graph.io/posts/nebula-operator-overview/) to it. Today, I would like to introduce my practice on Nebula Operator on cloud.

# About Nebula Operator

What is Nebula Operator? You can refer to [Nebula Operator Overview: Automated Operation on Kubernetes](https://nebula-graph.io/posts/nebula-operator-overview/). Today, this article will focus on the practice on Nebula Operator. I hope it could help you get started with it soon and enjoy NebulaGraph.

# Practicing Nebula Operator on Cloud

In this section, I will introduce the process of deploying and using Nebula Operator on cloud. Alibaba Cloud services are used, but the process is applicable to the similar services of other cloud service providers.

## Installation Tools

Install the following tools on your on-premises machine:

* [Kubectl](https://kubernetes.io/zh/docs/tasks/tools/)
* [Helm](https://helm.sh/zh/docs/intro/install/)
* [Docker](https://docs.docker.com/get-docker/)

For the installation information, see their documentations.

## Creating Kubernetes Cluster on Cloud

Nebula Operator is implemented for Kubernetes applications, so Kubernetes is necessary for practicing Nebula Operator.

This practice was performed on a managed Kubernetes cluster on Alibaba Cloud, so the first thing is to log on to the Alibaba Cloud Container Service for Kubernetes (ACK) console and then to create a managed Kubernetes cluster. The configurations must meet your needs. 

NOTE: To facilitate access to the Kubernetes API Server from Internet, Expose API Server with EIP was enabled for this practice. Whether to enable it or not is determined by your needs. If it is not enabled, you need to make sure that your on-premises machine can connect to the Kubernetes cluster. Configure other parameters as required.

When the Kubernetes cluster starts, in the Connection Information tab, copy the Public Access content in the code block to the $HOME/.kube/config file of your on-premises machine.

And then on your on-premises machine, run the following command to check the connection to your Kubernetes cluster.

```plain
$ kubectl get nodes
NAME                         STATUS   ROLES    AGE   VERSION
cn-beijing.192.168.250.13    Ready    <none>   51m   v1.20.4-aliyun.1
cn-beijing.192.168.250.185   Ready    <none>   51m   v1.20.4-aliyun.1
cn-beijing.192.168.250.89    Ready    <none>   51m   v1.20.4-aliyun.1
```

## Installing Dependencies for Nebula Operator

Install all the dependencies listed in this section for Nebula Operator.

### Installing CertManager

Run the following command to install [CertManager](https://cert-manager.io/).

```plain
 Install CertManager
$ helm install cert-manager cert-manager --repo https://charts.jetstack.io \
    --namespace cert-manager --create-namespace --version v1.3.1 \
    --set installCRDs=true
# Wait a moment and then check whether CertManager is started successfully.
$ kubectl -n cert-manager get pod
NAME                                       READY   STATUS    RESTARTS   AGE
cert-manager-7998c69865-jfw9x              1/1     Running   0          93s
cert-manager-cainjector-7b744d56fb-846w9   1/1     Running   0          93s
cert-manager-webhook-7d6d4c78bc-ssk4w      1/1     Running   0          93s
```

### Installing OpenKruise

Run the following command to install [OpenKruise](https://openkruise.io/).

```plain
# Install OpenKruise
$ helm install kruise \
    https://github.com/openkruise/kruise/releases/download/v0.8.1/kruise-chart.tgz
# Wait for a moment and then check whether OpenKruise is started successfully.
$ kubectl -n kruise-system get pod
NAME                                         READY   STATUS    RESTARTS   AGE
kruise-controller-manager-6797f89d9b-ppv65   1/1     Running   0          49s
kruise-controller-manager-6797f89d9b-wlkbd   1/1     Running   0          49s
kruise-daemon-7rljq                          1/1     Running   0          49s
kruise-daemon-8kd8d                          1/1     Running   0          49s
kruise-daemon-n6tdw                          1/1     Running   0          49s
```

## Adding Nebula Operator Charts

Run the following command to add [Nebula Operator Charts](https://vesoft-inc.github.io/nebula-operator/charts).

```plain
# Add the Nebula Operator Charts repository.
$ helm repo add nebula-operator https://vesoft-inc.github.io/nebula-operator/charts
# Update the repository.
$ helm repo update
```

## Installing Nebula Operator

If you cannot pull the `gcr.io` or `k8s.gcr.io` image, use mirrors. For example, in this practice, the following mirrors were used.  

|Original Images|Mirrors|
|:----|:----|
|[gcr.io/kubebuilder/kube-rbac-proxy:v0.8.0](http://gcr.io/kubebuilder/kube-rbac-proxy:v0.8.0)|kubesphere/kube-rbac-proxy:v0.8.0|
|[k8s.gcr.io/kube-scheduler:v1.18.8](http://k8s.gcr.io/kube-scheduler:v1.18.8)|kubesphere/kube-scheduler:v1.18.8|

You can run the following command to view all the configurable parameters.

```plain
$ helm show values nebula-operator/nebula-operator
```

In this practice, I followed this procedure to install Nebula Operator.

```plain
# Install Nebula Operator
$ helm install nebula-operator nebula-operator/nebula-operator \
    --namespace nebula-operator-system --create-namespace --version 0.1.0 \
    --set image.kubeRBACProxy.image=kubesphere/kube-rbac-proxy:v0.8.0 \
    --set image.kubeScheduler.image=kubesphere/kube-scheduler:v1.18.8
# Wait for a moment and check whether Nebula Operator is started successfully.
$ kubectl -n nebula-operator-system get pod
NAME                                                             READY   STATUS    RESTARTS   AGE
nebula-operator-controller-manager-deployment-6968547fff-k62b4   2/2     Running   0          19s
nebula-operator-controller-manager-deployment-6968547fff-lhpdx   2/2     Running   0          19s
nebula-operator-scheduler-deployment-7c5fc7945-hbkv8             2/2     Running   0          19s
nebula-operator-scheduler-deployment-7c5fc7945-sxc7w             2/2     Running   0          19s
```

If Cluster Domain of Kubernetes are customized, modify the preceding installation command by adding configuration of `kubernetesClusterDomain`. 

```plain
# Install Nebula Operator and replace <<YourCustomCLusterDomain>> with your own cluster domain.
$ helm install nebula-operator nebula-operator/nebula-operator \
    --namespace nebula-operator-system --create-namespace --version 0.1.0 \
    --set image.kubeRBACProxy.image=kubesphere/kube-rbac-proxy:v0.8.0 \
    --set image.kubeScheduler.image=kubesphere/kube-scheduler:v1.18.8 \
    --set kubernetesClusterDomain=<<YourCustomCLusterDomain>>
```

## Deploying NebulaGraph Cluster

So far, Nebula Operator has been ready. Now, let's deploy a NebulaGraph cluster for handling graph data. 

The first one is to know StorageClass information, which will be used to configure the persistent volume storage for the NebulaGraph cluster.

```plain
$ kubectl get sc
NAME                       PROVISIONER                       RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
alicloud-disk-available    diskplugin.csi.alibabacloud.com   Delete          Immediate              true                   100m
alicloud-disk-efficiency   diskplugin.csi.alibabacloud.com   Delete          Immediate              true                   100m
alicloud-disk-essd         diskplugin.csi.alibabacloud.com   Delete          Immediate              true                   100m
alicloud-disk-ssd          diskplugin.csi.alibabacloud.com   Delete          Immediate              true                   100m
alicloud-disk-topology     diskplugin.csi.alibabacloud.com   Delete          WaitForFirstConsumer   true                   100m
```

As you can see from the result of the preceding command, five types of StorageClass are supported on Alibaba Cloud. For this practice, alicloud-disk-ssd was used. If you want to use the services provided by another cloud service provider, choose an applicable StorageClass type.

NOTE: Each cloud service provider may set limits on the storage capacity for your application. For example, on Alibaba Cloud, [the limit on SSD](https://partners-intl.aliyun.com/help/doc-detail/25513.htm) is from 20 GiB to 32,768 GiB. Therefore, you must specially consider this configuration when deploying a NebulaGraph cluster.

To view all the configurable parameters, you can run the following command.

```plain
$ helm show values nebula-operator/nebula-cluster
```

In this practice, all these commands were run to deploy a NebulaGraph cluster.

```plain
# Name the NebulaGraph cluster.
$ export NEBULA_CLUSTER_NAME=nebula

# Create a namespace for the NebulaGraph cluster.
$ export NEBULA_CLUSTER_NAMESPACE=nebula

# Specify StorageClass type for the NebulaGraph cluster. In this example, alicloud-disk-ssd is used.
$ export STORAGE_CLASS_NAME=alicloud-disk-ssd

# Specify the storage size for the three processes of NebulaGraph.
$ export STORAGE_SIZE_GRAPHD=20Gi
$ export STORAGE_SIZE_METAD=20Gi
$ export STORAGE_SIZE_STORAGED=20Gi

# Deploy the NebulaGraph cluster.
$ helm install ${NEBULA_CLUSTER_NAME} nebula-operator/nebula-cluster \
    --namespace ${NEBULA_CLUSTER_NAMESPACE} --create-namespace --version 0.1.0 \
    --set nameOverride=${NEBULA_CLUSTER_NAME} \
    --set nebula.storageClassName="${STORAGE_CLASS_NAME}" \
    --set nebula.graphd.storage="${STORAGE_SIZE_GRAPHD}" \
    --set nebula.metad.storage="${STORAGE_SIZE_METAD}" \
    --set nebula.storaged.storage="${STORAGE_SIZE_STORAGED}"

# Wait a moment and check whether the NebulaGraph cluster is started successfully.
$ kubectl -n ${NEBULA_CLUSTER_NAMESPACE} get nebulacluster
NAME     GRAPHD-DESIRED   GRAPHD-READY   METAD-DESIRED   METAD-READY   STORAGED-DESIRED   STORAGED-READY   AGE
nebula   2                2              3               3             3                  3                4m10s
$ kubectl -n ${NEBULA_CLUSTER_NAMESPACE} get pod
NAME                READY   STATUS    RESTARTS   AGE
nebula-graphd-0     1/1     Running   0          96s
nebula-graphd-1     1/1     Running   0          96s
nebula-metad-0      1/1     Running   0          97s
nebula-metad-1      1/1     Running   0          97s
nebula-metad-2      1/1     Running   0          97s
nebula-storaged-0   1/1     Running   0          97s
nebula-storaged-1   1/1     Running   0          97s
nebula-storaged-2   1/1     Running   0          97s
```

Of course, you can also run the following command to upgrade the cluster to have five nebula-storaged process instances. 

```plain
# Upgrade the NebulaGraph cluster.
$ helm upgrade ${NEBULA_CLUSTER_NAME} nebula-operator/nebula-cluster \
    --namespace ${NEBULA_CLUSTER_NAMESPACE} --create-namespace --version 0.1.0 \
    --set nameOverride=${NEBULA_CLUSTER_NAME} \
    --set nebula.storageClassName="${STORAGE_CLASS_NAME}" \
    --set nebula.graphd.storage="${STORAGE_SIZE_GRAPHD}" \
    --set nebula.metad.storage="${STORAGE_SIZE_METAD}" \
    --set nebula.storaged.storage="${STORAGE_SIZE_STORAGED}" \
    --set nebula.storaged.replicas=5
#  Wait for a moment and check whether the cluster is started successfully.
$ kubectl -n ${NEBULA_CLUSTER_NAMESPACE} get nebulacluster
NAME     GRAPHD-DESIRED   GRAPHD-READY   METAD-DESIRED   METAD-READY   STORAGED-DESIRED   STORAGED-READY   AGE
nebula   2                2              3               3             5                  5                6m12s
$ kubectl -n ${NEBULA_CLUSTER_NAMESPACE} get pod
NAME                READY   STATUS    RESTARTS   AGE
nebula-graphd-0     1/1     Running   0          2m30s
nebula-graphd-1     1/1     Running   0          2m30s
nebula-metad-0      1/1     Running   0          2m30s
nebula-metad-1      1/1     Running   0          2m30s
nebula-metad-2      1/1     Running   0          2m30s
nebula-storaged-0   1/1     Running   0          2m30s
nebula-storaged-1   1/1     Running   0          2m30s
nebula-storaged-2   1/1     Running   0          2m30s
nebula-storaged-3   1/1     Running   0          52s
nebula-storaged-4   1/1     Running   0          52s
```

For more information, see [Install Nebula Cluster with helm](https://github.com/vesoft-inc/nebula-operator/blob/master/doc/user/nebula_cluster_helm_guide.md) in NebulaGraph Database Manual.

## Connecting to NebulaGraph Cluster

If the NebulaGraph cluster is started successfully, here comes the last step: Connect to the cluster.

### Connecting from Inside of Kubernetes

Firstly, on Kubernetes, run the following command to start [NebulaGraph Console](https://github.com/vesoft-inc/nebula-console). 

```plain
$ cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: nebula-console
spec:
  containers:
    - name: nebula-console
      image: vesoft/nebula-console:v2-nightly
      command:
      - sleep
      - "1000000"
EOF
```

And then, run this command to connect to the cluster via the created NebulaGraph Console.

```plain
$ kubectl exec -it nebula-console -- \
    nebula-console -u u -p p --addr ${NEBULA_CLUSTER_NAME}-graphd-svc.${NEBULA_CLUSTER_NAMESPACE}.svc --port 9669
2021/06/23 06:21:22 [INFO] connection pool is initialized successfully
Welcome to NebulaGraph!
(u@nebula) [(none)]> show hosts
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| Host                                                                  | Port | Status   | Leader count | Leader distribution  | Partition distribution |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-0.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-1.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-2.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-3.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-4.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "Total"                                                               |      |          | 0            |                      |                        |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
Got 4 rows (time spent 7669/9367 us)
Wed, 23 Jun 2021 06:21:26 UTC
```

### Connecting from Outside of Kubernetes

If you want to connect to the services inside Kubernetes from outside, use `hostPort`, `hostNetwork`, `Ingress`, `LoadBalancer`, and so on. In this practice, I took advantages of the functionalities of Alibaba Cloud and used `LoadBalancer`.

***DO NOT: This operation will expose your NebulaGraph Cluster to the public, so do not use it in the production environment.***

Firstly, change the type of `nebula-graphd` to `LoadBalancer`, and then view `EXTERNAL-IP`. 

```plain
# Change the type of nebula-graphd to LoadBalancer.
$ kubectl patch -n ${NEBULA_CLUSTER_NAMESPACE} svc ${NEBULA_CLUSTER_NAME}-graphd-svc \
    -p '{"spec": {"type": "LoadBalancer"}}'
# View EXTERNAL-IP. If "pending" is shown, wait a moment and try again.
$ kubectl -n ${NEBULA_CLUSTER_NAMESPACE} get svc nebula-graphd-svc
NAME                TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)                                          AGE
nebula-graphd-svc   LoadBalancer   172.16.85.222   x.x.x.x         9669:31460/TCP,19669:32579/TCP,19670:31481/TCP   27m
```

Now, you can use the `EXTERNAL-IP` address (for example, `x.x.x.x` in this example) to connect to the cluster.

```plain
$ export EXTERNAL_IP=x.x.x.x
$ docker run -it --rm vesoft/nebula-console:v2-nightly -u u -p p --addr ${EXTERNAL_IP} --port 9669
2021/06/23 06:42:17 [INFO] connection pool is initialized successfully
Welcome to NebulaGraph!
(u@nebula) [(none)]> show hosts
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| Host                                                                  | Port | Status   | Leader count | Leader distribution  | Partition distribution |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-0.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-1.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-2.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-3.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "nebula-storaged-4.nebula-storaged-headless.nebula.svc.cluster.local" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
| "Total"                                                               |      |          | 0            |                      |                        |
+-----------------------------------------------------------------------+------+----------+--------------+----------------------+------------------------+
Got 4 rows (time spent 3747/60433 us)
Wed, 23 Jun 2021 06:42:21 UTC
```

# Enjoy

**You made it!**

**Have fun with NebulaGraph!**

Join our [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-7ybejuqa-NCZBroh~PCh66d9kOQj45g) if you want to discuss with the rest of the NebulaGraph community!


A step-by-step guide on deploying Nebula Operator on public cloud services.

Practicing Nebula Operator on Cloud


![Nebula Operator Overview](https://user-images.githubusercontent.com/57335825/116524538-16aaee00-a90a-11eb-9299-bcd025af1609.png)

Before introducing Nebula Operator, you should know what the Operator is.

An Operator aims to package, deploy, and manage Kubernetes applications. By extending the functionality of the Kubernetes API, it creates, configures, and manages complex application instances on behalf of a user. It is built based on the Custom Resource Definition (CRD) and its associated Controller, covering domain or application-specific knowledge to automate the entire life cycle of the software it manages.

In Kubernetes, controllers of the control plane implement control loops that repeatedly compare the desired state of a cluster with its actual state. If the actual state does not match the desired state, the controller continues managing internal business logic until the desired state is achieved.

![reconcile loop](https://user-images.githubusercontent.com/57335825/116524709-45c15f80-a90a-11eb-87a1-447527d07f7b.png)

Nebula Operator abstracts deployment management of NebulaGraph as CRD. By combining multiple built-in API objects including `StatefulSet`, `Service`, and `ConfigMap`, the routine management and maintenance of NebulaGraph are coded as a control loop. When a CR instance is submitted, Nebula Operator drives the database cluster to the final state according to the control process.

# Functionalities of Nebula Operator

## Custom Resource Definition

Here is the CRD file for the deployment of a NebulaGraph cluster. From it, you can see the core functionalities of Nebula Operator.

```yaml
apiVersion: apps.nebula-graph.io/v1alpha1
kind: NebulaCluster
metadata:
  name: nebula
  namespace: default
spec:
  graphd:
    resources:
      requests:
        cpu: "500m"
        memory: "500Mi"
    replicas: 1
    image: vesoft/nebula-graphd
    version: v2.0.0
    storageClaim:
      resources:
        requests:
          storage: 2Gi
      storageClassName: gp2
  metad:
    resources:
      requests:
        cpu: "500m"
        memory: "500Mi"
    replicas: 1
    image: vesoft/nebula-metad
    version: v2.0.0
    storageClaim:
      resources:
        requests:
          storage: 2Gi
      storageClassName: gp2
  storaged:
    resources:
      requests:
        cpu: "500m"
        memory: "500Mi"
    replicas: 3
    image: vesoft/nebula-storaged
    version: v2.0.0
    storageClaim:
      resources:
        requests:
          storage: 2Gi
      storageClassName: gp2
  reference:
    name: statefulsets.apps
    version: v1
  schedulerName: default-scheduler
  imagePullPolicy: IfNotPresent
```

In the spec section, three items must be focused, that is, graphd, metad, and storaged. They represent Graph Service, Meta Service, and Storage Service respectively. The controllers will check the state of StatefulSet, Service, and ConfigMap in sequence in the control loop. If a dependent API object is not created or NebulaGraph component service regulation is abnormal, the control loop will be terminated and wait for the next one. This process is repeated again and again.

At present, only the essential configuration parameters for the operation are provided as CRDs, including resources, replicas, image, and schedulerName. In the future, more configuration parameters will be provided for Nebula Operator to meet your scenarios.

![reconcile](https://user-images.githubusercontent.com/57335825/116524916-88833780-a90a-11eb-8f75-c1f6227c8da6.png)

## Scaling

Scaling out Storage is divided into two stages. In the first stage, you need to wait for the status of all newly created Pods to be Ready. In the second stage, the BALANCE DATA command is executed. The execution of BALANCE DATA is defined in the StorageBalancer CRD. Through both stages, the scaling process of the controller replicas is decoupled from the balancing data process to realize the customization of the balancing data task such as adding task execution time and executing it at low traffic. Such an implementation can effectively reduce the impact of data migration on online services, which is in line with NebulaGraph principle: Balancing data is not fully automated and when to balance data is decided by users.

![scale out](https://user-images.githubusercontent.com/57335825/116524993-a05abb80-a90a-11eb-9a8a-91a617d021e4.png)

Scaling in and out Storage are the opposite processes. To scale in Storage, some nodes must be removed safely, which can be completed by running the BALANCE DATA REMOVE $host_list command internally. After the nodes are removed, the size of Storage Pods will be shrunk.

NOTE: The following figures show how Storage is scaled in, but it cannot be used as a deployment reference. In a high-availability scenario, three online replicas are necessary.

![scale in](https://user-images.githubusercontent.com/57335825/116525050-b5cfe580-a90a-11eb-9a8a-ab869655a478.png)

![scale in](https://user-images.githubusercontent.com/57335825/116525103-c41e0180-a90a-11eb-8952-6c90e9c01628.png)

## Balance Scheduling

For scheduling, Nebula Operator provides two options: the default scheduler and the custom scheduler based on the scheduler extender interface.

Topology spread constraints of the default scheduler can be used to spread Pods evenly across your cluster. By default, the key of node label is set to kubernetes.io/hostname in Nebula Operator. It will be configurable in the future. The affinity-based scheduling policies are not applied because such policies control how Pods are packed or scattered.  "PodAffinity" is to pack multiple Pods into a specific topology domain, which is called "packed", while "PodAntiAffinity" is to ensure that only one Pod can be scheduled into a single topology domain, which is called "scattered". However, these scheduling policies cannot meet the scenarios that require Pods to be spread as evenly as possible, especially in a distributed scenario, where high-availability needs to be spread across multiple topology domains.

Of course, if you are using an earlier version of Kubernetes and cannot experience the topology spread constraints feature, you can use Nebula-Scheduler. Its core logic is to ensure that the Pods of each component can be evenly spread across the specified topology domains.

## Workload Controllers

Nebula Operator is going to support a variety of workload controllers. By configuring reference, you can choose a workload controller. Currently, besides the native StatefulSet, Nebula Operator supports the AdvancedStatefulSet feature provided by Community Edition of OpenKruise. Users can use the advanced features of Nebula Operator such as in-place upgrade and designating children nodes for a specific node to meet their own business needs. Of course, parameter configurations in Operator are necessary to enable these features. Currently, only parameters for in-place upgrade are available.

```yaml
  reference:
    name: statefulsets.apps
    version: v1
```  

## Other Functionalities

Other functionalities such as WebHook supporting configuration verification in high-availability mode and updating configuration of custom parameters are not introduced in this article. These features aim to allow Nebula Operator to manage NebulaGraph clusters more securely and conveniently on behalf of you. For more information, refer to the documentation on GitHub.

# FAQ

> Can Nebula Operator be used outside of Kubernetes?

No. Operator depends on Kubernetes. It is an extension of the Kubernetes API. It is a K8s tool.

> How to ensure the stability and availability of upgrade and scaling? If the upgrade or scaling fails, can a cluster roll back? 

We recommend that you back up your data before the operation to make sure that your cluster can roll back after a failure. At present, Nebula Operator does not support backing up data before the operation, but it will do after iterations. 

> Can I use Nebula Operator to manage a NebulaGraph v1.x cluster?

No. NebulaGraph v1.x does not support internal domain name resolution. Nebula Operator needs this feature, so it is not compatible.

> Can the use of local storage ensure the stability of a cluster?

No guarantee now. If local storage is used, it means that Pods bind specific nodes, and currently, the Operator cannot fail over after a local storage node goes down. However, using network storage does not have such a problem.

> When can Nebula Operator support the upgrade? 

Nebula Operator needs to be in line with NebulaGraph. When NebulaGraph supports rolling upgrade, Nebula Operator will have this feature. 

Nebula Operator is now open sourced and can be accessed via GitHub: [https://github.com/vesoft-inc/nebula-operator](https://github.com/vesoft-inc/nebula-operator).

Interested in Nebula Operator? Join the NebulaGraph [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-7ybejuqa-NCZBroh~PCh66d9kOQj45g) to discuss with the community!


Nebula Operator is a plug-in to deploy, operate and maintain NebulaGraph automatically on K8s， which makes NebulaGraph a real cloud-native graph database.

Nebula Operator Overview: Automated Operation on Kubernetes


![How to Deploy Self-Host Discourse Forum with Global CDN](https://user-images.githubusercontent.com/57335825/78754651-6d195780-79aa-11ea-9889-5a80ef550295.png)

Discourse is an open source forum software developed by Jeff Atwood, the co-founder of Stack Overflow. The application is written with Ruby on Rails. 

As a product designed for the next decade of the Internet, Discourse breaks with existing forum software by its commitment to open source,  concise page style and unique content system. Famous companies like Car Talk are using Discourse to set up forums for their products.

As an open source forum project, Discourse has the following highlights compared to other forums:

- **Highly customized**: Discourse lists 25 major setting items that including 300+ sub items. Even if everyone is using Discourse to build their forums, each forum can have its own unique style.
- **Rich plugins**: Together with its active community, Discourse provides a big variety of plugins for  users to customize their forums such as the navi bar and banner image.
- **Integrations**: Discourse can be fully integrated with other third-party tools like Google Analytics, Slack and WordPress.
- **Free**: Discourse has an option to host the forum at $100/Month for you. However, you can totally deploy the service on your own without spending a penny.
- **Easy to get started**: Discobot is a customizable bot  that teaches new users in an interactive way how to use  features like bookmarking a topic, oneboxing links (embedded previews), adding emoji, name mentions, simple formatting, adding a picture to a reply, flagging posts and the search function.


NebulaGraph chooses Discourse for its rich plugins and the customizable forum settings. However, we are not going to introduce how to build Discourse in this post. (It's a rather simple task, just Google it.) We will introduce how to deploy Discourse with global CDN for the NebulaGraph community.

# Deploying Discourse

## Why Self-Hosting

As mentioned above, Discourse provides hosting service, but we decided to self-host our forum for the following reasons:

1. Unstable access in China
1. Limited plugin modification
1. Not able to customize the internet settings



We have customized the internet settings and modified some plugins on the self-hosted forum so that our community members across the globe get to access it faster.

## Self-Hosting Prerequisites

Below is a list of what's required for self-host a Discourse forum:

- Linux servers with more than 2G memory, if your server memory is 1G, you need to enable the SWAP partition
- A domain with full control, which we will use when registering for mail and CDN services
- A Cloudflare account, which helps speed up your site and improve security
- An available SMTP mail service

## Self Host a Discourse Forum with Cloudflare CDN

### Introduction to Cloudflare

Cloudflare is a global CDN  service provider. In addition to the CDN service, it also provides services like DNS query, DDoS mitigation and cache acceleration service.

Compared with other CDN service providers, Cloudflare  provides  qualified services at lower price (free most of the times). Therefore, Cloudflare has a very large user base and is our first choice.

### Step 1: Adding DNS records for Cloudflare

Add DNS records first, which will reduce the possibility of being rejected by the _Let's encrypt_ certificate in your first deployment. In the Cloudflare dashboard, click the the DNS app, add Type A record and point it to the server IP.

![Add DNS records for Cloudflare](https://user-images.githubusercontent.com/57335825/78763342-9987a080-79b7-11ea-9a47-39428e0cd149.png)


**Takeaway:**

Don't set the Proxy status option as Proxied because that will result in inaccessibility due to too many redirects. Enable the Proxy status setting after all configuration is finished correctly.

### Step 2: Configure Cloudflare SSL/TLS

_**Full**_ and _**Flexible**_ are the most commonly used SSL types in Cloudflare. We need to configure SSL before enabling the CDN.

Select mode _**Full**_ in the SSL/TLS dashboard. **_Full_** ensures a secure connection between both the visitor and your Cloudflare domain and between Cloudflare and your web server.

![Configure Cloudflare SSL/TLS](https://user-images.githubusercontent.com/57335825/78763496-cb006c00-79b7-11ea-83e5-f7006490ca64.png)


Then click the Origin Server tab to create a certificate. Select RSA in the Private key type. RSA is the most compatible certificate type while ECDSA has better performance.

Select your forum domain in the hostname list protected by the certificate. In our case, we select discuss.nebula-graph.io. Select the certificate validity to 1 year. Click next to get your certificate public key and private key, each saved as `ssl.crt` and `ssl.key` respectively. Keep your keys properly because we will use them in the following steps.

![Configure Cloudflare SSL/TLS - Domain](https://user-images.githubusercontent.com/57335825/78763658-03a04580-79b8-11ea-991c-30f43d53fd93.png)


### Step 3: Configure and deploy Discourse

Discourse docker image makes it much easier to deploy a Discourse forum. Install Docker first then run the image to get started.

### Step 4: Install Discourse

Clone the [Official Discourse Docker Image](https://github.com/discourse/discourse_docker) into `/var/discourse`.

```bash
sudo -s
git clone https://github.com/discourse/discourse_docker.git /var/discourse
cd /var/discourse
```

Launch the setup tool in `/var/discourse`.

```bash
./discourse-setup
```

Answer the following questions when prompted:

```bash
Hostname for your Discourse? [discourse.example.com]:
Email address for admin account(s)? [me@example.com,you@example.com]:
SMTP server address? [smtp.example.com]:
SMTP port? [587]:
SMTP user name? [user@example.com]:
SMTP password? [pa$$word]:
Let's Encrypt account email? (ENTER to skip) [me@example.com]:
```

Please be noted that if the DNS records have not been propagated to the DNS server used by the server, the SSL certificate auto-registration service of Let ’s Encrypt is not available. Since we will use the Cloudflare certificate applied in the above instruction, we can skip the Let's Encrypt account email here.

About 10 minutes later, you can visit your own Discourse forum via the domain set previously. If you get 502 error on the first visit, this is because the service has not been fully initialized. You just wait and retry.

![Install Discourse](https://user-images.githubusercontent.com/57335825/78763841-3fd3a600-79b8-11ea-94ce-6a275186daf3.png)

### Step 5: Configure Discourse

The configuration file of Discourse is located at `/var/discourse/containers/app.yml`.

**Set email server**
Email server setup and maintenance is very difficult even for experienced system administrators, and getting any part of the complex required email setup wrong means your email won't be delivered. For most Email services, you only need to configure the SMTP server address, port, user name and password. You can get the STMP server address and the available port on the help page of the Email service provider. Some personal mail may need special password to enable the SMTP service.

However, for Office365 and Tencent enterprise mail, you need to manually specify the account verification method as login in the `app.yml` file.

The following are template configurations for email service providers known to work with Discourse.

```bash
 DISCOURSE_SMTP_ADDRESS: smtp.office365.com
 DISCOURSE_SMTP_PORT: 587
 DISCOURSE_SMTP_USER_NAME: example@office365.com
 DISCOURSE_SMTP_PASSWORD: **********
 DISCOURSE_SMTP_ENABLE_START_TLS: true
 DISCOURSE_SMTP_AUTHENTICATION: login
```

This is because the default Discourse mailbox authentication method is `plain`. If you are not sure which method to use for authentication, monitor with swaks, a mail service testing tool. For example:<

```bash
swaks --to [Inbox] --from [Outbox] --server [SMTP server address] --auth [login/plain] --auth-user [Outbox] -tls -p [port]
```

While ensuring that you can pass the Discourse sending test, you also need to set two other options to ensure that users can receive mail.

One is the notification mail under the Setting-Required in the forum. You need to configure the email here the same as the SMTP login email. The other one is the disable emails, which is usually set to non-staff after forum migration and backup recovery. Set it to no to recover email sending.

**Set SSL and CDN**

Introduce two template files: `templates/cloudflare.template.yml` and `templates/web.ssl.template.yml` to your `app.yml` file. Log in to Cloudflare again, change the DNS record from DNS only to Proxied and wait for the validation.

```
 DISCOURSE_SMTP_ADDRESS: smtp.office365.com
 DISCOURSE_SMTP_PORT: 587
 DISCOURSE_SMTP_USER_NAME: example@office365.com
 DISCOURSE_SMTP_PASSWORD: **********
 DISCOURSE_SMTP_ENABLE_START_TLS: true
 DISCOURSE_SMTP_AUTHENTICATION: login
```

Put the certificate file created in step 2 in `/var/discourse/shared/standalone/ssl`.

**Add new plugins (optional)**

There are a large number of Discourse plugins available. Just pick the ones that are useful to you. For example, if you are reaching a global audience, then you might need a translation plugin to help people understand posts written in different languages.

Configure links that can be fetched by git in the hooks field in file `app.yml`. When the Discourse Docker container is re-created, your new plugins are installed.

```
# Plugins go here
# see https://meta.discourse.org/t/19157 for details
hooks:
  after_code:
    - exec:
        cd: $home/plugins
        cmd:
          - git clone https://github.com/discourse/docker_manager.git
          - git clone https://github.com/discourse/discourse-translator.git
```

## Get Started with Your Forum

After completing the above configuration, run `./launcher rebuild app` in the `/var/discourse`  and wait for 10 minutes to complete the final building.

If you are a personal site owner, consider installing and configuring Fail2ban to protect the ssh service security. Discourse will create a weekly backup and save it in the local `/var/discourse/shared/standalone/backups` directory. You can set _rsync_ for a local backup. If an Amazon S3 service is available, you can also configure the related information of the S3 service in the background. Discourse will automatically upload the backup to the corresponding S3 instance after the backup is completed.

Now you have your own Discourse forum with global CDN acceleration. Benefiting from the global CDN and full link SSL, your forum can be securely accessed anywhere in the world. Visiting the forum from your domain name, and fill in the related information to initialize the forum and create an administrator account. You can start the forum service after confirming registration through the link in the email.

# Conclusion

That's pretty much how we have self hosted the NebulaGraph [forum](https://discuss.nebula-graph.io/) with global CDN. If you have any thoughts or suggestions, feel free to leave us comments below.

> _Hi, I'm George and I work as Implementation Engineer at NebulaGraph. I've been working in the devops field for years and would like to share what I've learn with you. Hope my post is helpful to you. Do let me know about your thoughts. Appreciate that!_

# You might also like

1. [Automating Your Project Processes with Github Actions](https://nebula-graph.io/posts/github-action-automating-project-process/)
1. [Compiling Trouble Shooting: Segmentation Fault and GCC Illegal Instruction](https://nebula-graph.io/posts/segmentation-fault-gcc-illegal-instruction-trouble-shooting/)


This article explains in detail how NebulaGraph self-hosts our Discourse forum with global CDN to ensure decent access speed for global users.

How to Deploy Self-Hosted Discourse Forum With Global CDN


![Compare Multiple Projects with this GitHub Stats tool](https://user-images.githubusercontent.com/57335825/83610262-09d41d80-a534-11ea-875a-5e696df2c6f0.png)

If you have project code hosted on GitHub, chances are you might be interested in checking some numbers and stats such as stars, commits and pull requests.

You might also want to compare some similar projects in terms of the above mentioned stats, for whatever reasons that interest you.

We have the right tool for you: the simple and easy-to-use little tool called [GitHub Stats](https://vesoft-inc.github.io/github-statistics/).

Let's dive right in to what we can get out of it.

# Getting started

This interactive tool is really easy to use. Follow the three steps below and you'll get what you want in real-time:

1. Head to the [GitHub repo](https://vesoft-inc.github.io/github-statistics/) of the tool
1. Enter as many projects as you need to check on
1. Hit the Update button beside each metric

In this article we are going to compare three most popular machine learning projects for you.  

![image](https://user-images.githubusercontent.com/38887077/75141197-69e44800-572b-11ea-9dc5-308c7ed70dde.png)

# General repository information 

![image](https://user-images.githubusercontent.com/38887077/75141248-87191680-572b-11ea-882f-31ab726ee7af.png)

So basically these metrics can answer the following questions for you:

1. Which is the freshest project?

      tensorflow wins because its last push happened just an hour ago.

2. Which project gets the most attention?

      tensorflow wins because it has the most watchers.

# Popularity metrics

It's common that you want to know which project gains the most popularity. 

But how can you measure popularity?

By stars and forks each project has gained.

See the screenshots below for the comparison results:

## Star

![image](https://user-images.githubusercontent.com/38887077/75141279-95ffc900-572b-11ea-8476-41b51d52fe7c.png)

## Fork

![image](https://user-images.githubusercontent.com/38887077/75141281-98622300-572b-11ea-8ce2-37967ad6c6ac.png)

Apparently tensorflow gets the strongest momentum during the entire life cycle.

# Maturity metrics

Besides popularity, you might also care about the maturity of a project, which is worth considering. Generally speaking, the more mature a project is, the more powerful as well as stable it is.

How to measure the maturity of a project?

By the most recent version, number of issues and number of pull requests.

See the screenshots below for the comparison results:

## Release

![image](https://user-images.githubusercontent.com/38887077/75141348-b7f94b80-572b-11ea-81f2-8658ab9ecbc7.png)

## Issues

![image](https://user-images.githubusercontent.com/38887077/75141395-ce9fa280-572b-11ea-92fe-9f0980f51414.png)

## Pull Requests

![image](https://user-images.githubusercontent.com/38887077/75141426-da8b6480-572b-11ea-8c4f-b32478af217a.png)

tensorflow and Pytorch have been maintained constantly while caffe is still at its 1.0 version with much fewer issues and pull requests than its two peers.

It's your decision to make which to follow.

# Conclusion

Data matters. And we hope this simple GitHub Stats tool can bring you the insight required. Also feel free to use it your own way.

Submit an issue if you find any valuable metric is missing in the tool. Here's the project repo again: [https://vesoft-inc.github.io/github-statistics/](https://vesoft-inc.github.io/github-statistics/)

Enjoy!

# You might also like

1. [NebulaGraph Architecture — A Bird’s View](https://nebula-graph.io/posts/nebula-graph-architecture-overview/)
1. [An Introduction to NebulaGraph's Storage Engine](https://nebula-graph.io/posts/nebula-graph-storage-engine-overview/)
1. [An Introduction to NebulaGraph’s Query Engine](https://nebula-graph.io/posts/nebula-graph-query-engine-overview/)


This post introduces a React based tool to help you get the stats of GitHub metrics like stars, forks, commits, etc. so that you can make an informed decision which project to follow.

Tag