Docker安装部署neo4j的实战过程

韦志

前言

Neo4j是一个高性能的,NOSQL图形数据库，本身就支持集群部署，今天要搭建的就是neo4j的因果集群，其中分为：
核心节点：core-server，可以对数据进行读写的中心节点，通过选举确定leader，follower.
只读节点：read-replica，只提供数据访问的只读节点，需要连接核心节点，可以非常方便的进行扩展

一、Docker 安装部署neo4j

第一步，从镜像源中查找镜像

1. docker search neo4j

复制代码

第二步，拉取镜像源

1. docker pull neo4j(:版本号)
   
2. //缺省 “:版本号” 时默认安装latest版本的

复制代码

第三步，查看本地镜像，检验是否拉取成功

1. docker images

复制代码

启动容器

1. docker run -d --name container_name -p 27474:7474 -p 27687:7687 -v /home/neo4j/data:/data -v /home/neo4j/logs:/logs -v /home/neo4j/conf:/var/lib/neo4j/conf -v /home/neo4j/import:/var/lib/neo4j/import --env NEO4J_AUTH=neo4j/password neo4j

复制代码

1. -d --name container_name   //-d表示容器后台运行 --name指定容器名字
   
2.         -p 27474:7474 -p 27687:7687   //映射容器的端口号到宿主机的端口号；27474 为宿主机端口
   
3.         -v /home/neo4j/data:/data   //把容器内的数据目录挂载到宿主机的对应目录下
   
4.         -v /home/neo4j/logs:/logs   //挂载日志目录
   
5.         -v /home/neo4j/conf:/var/lib/neo4j/conf   //挂载配置目录
   
6.         -v /home/neo4j/import:/var/lib/neo4j/import   //挂载数据导入目录
   
7.         --env NEO4J_AUTH=neo4j/password   //设定数据库的名字的访问密码
   
8.         neo4j //指定使用的镜像

复制代码

修改配置文件

1. // 进入容器配置目录挂载在宿主机的对应目录，我这里是/home/neo4j/conf
   
2. cd /home/neo4j/conf
   
3. // vim编辑器打开neo4j.conf
   
4. vim neo4j.conf
   
5. // 进行以下更改
   
6. //在文件配置末尾添加这一行
   
7. dbms.connectors.default_listen_address=0.0.0.0  //指定连接器的默认监听ip为0.0.0.0，即允许任何ip连接到数据库
   
8. //修改
   
9. dbms.connector.bolt.listen_address=0.0.0.0:7687  //取消注释并把对bolt请求的监听“地址:端口”改为“0.0.0.0:7687”
   
10. dbms.connector.http.listen_address=0.0.0.0:7474  //取消注释并把对http请求的监听“地址:端口”改为“0.0.0.0:7474”

复制代码

重启neo4j容器

二、源码包安装 neo4j

1. // 命令下载
   
2. curl -O http://dist.neo4j.org/neo4j-community-3.4.5-unix.tar.gz
   
3. // 解压安装
   
4. tar -axvf neo4j-community-3.4.5-unix.tar.gz

复制代码

安装目录下找到conf目录下的neo4j.conf文件，修改相应配置

1. # 修改第22行load csv时l路径，在前面加个#，可从任意路径读取文件
   
2. #dbms.directories.import=import
   
3. 
   
4. # 修改35行和36行，设置JVM初始堆内存和JVM最大堆内存
   
5. # 生产环境给的JVM最大堆内存越大越好，但是要小于机器的物理内存
   
6. dbms.memory.heap.initial_size=5g
   
7. dbms.memory.heap.max_size=10g
   
8. 
   
9. # 修改46行，可以认为这个是缓存，如果机器配置高，这个越大越好
   
10. dbms.memory.pagecache.size=10g
    
11. 
    
12. # 修改54行，去掉改行的#，可以远程通过ip访问neo4j数据库
    
13. dbms.connectors.default_listen_address=0.0.0.0
    
14. 
    
15. # 默认 bolt端口是7687，http端口是7474，https关口是7473，不修改下面3项也可以
    
16. # 修改71行，去掉#，设置http端口为7687，端口可以自定义，只要不和其他端口冲突就行
    
17. dbms.connector.bolt.listen_address=:7687
    
18. 
    
19. # 修改75行，去掉#，设置http端口为7474，端口可以自定义，只要不和其他端口冲突就行
    
20. dbms.connector.http.listen_address=:7474
    
21. 
    
22. # 修改79行，去掉#，设置http端口为7473，端口可以自定义，只要不和其他端口冲突就行
    
23. dbms.connector.https.listen_address=:7473
    
24. 
    
25. # 修改227行，去掉#，允许从远程url来load csv
    
26. dbms.security.allow_csv_import_from_file_urls=true
    
27. 
    
28. # 修改246行，允许使用neo4j-shell，类似于mysql 命令行之类的
    
29. dbms.shell.enabled=true
    
30. 
    
31. # 修改248行，去掉#，设置连接neo4j-shell的端口，一般都是localhost或者127.0.0.1，这样安全，其他地址的话，一般使用https就行
    
32. dbms.shell.host=127.0.0.1
    
33. 
    
34. # 修改250行，去掉#，设置neo4j-shell端口，端口可以自定义，只要不和其他端口冲突就行
    
35. dbms.shell.port=1337
    
36. 
    
37. # 修改254行，设置neo4j可读可写
    
38. dbms.read_only=false
    
39. 
    
40. # 设置JDK，若系统默认是jdk1.8及以上可以不需要设置
    
41. JAVA_HOME=/usr/java/jdk1.8.0_144
    
42. JRE_HOME=/usr/java/jdk1.8.0_144/jre

复制代码

APOC下载
Neo4j插件APOC
将下载好的.jar文件直接放到neo4j安装目录下的plugins文件夹目录下就可以了。不要解压！！！
配置

1. neo4j安装目录下conf文件夹里的neo4j.conf
   
2. 将dbms.security.auth_enabled=false注释掉

复制代码

文件末尾加上：

1. dbms.sercurity.procedures.unrestricted=apoc.*
   
2. dbms.memory.pagecache.size=10g
   
3. dbms.memory.heap.initial_size=1g
   
4. dbms.memory.heap.max_size=4g

复制代码

三、k8s搭建NEO4J因果集

此集群是有状态的服务，所以使用k8s的StatefulSet进行部署，创建neo4j-core-server.yaml文件
部署NEO4J-CORE-SERVER集群

1. # 先创建neo4j的命名空间namespace
   
2. ---
   
3. apiVersion: v1
   
4. kind: Namespace
   
5. metadata:
   
6.    name: neo4j
   
7.    labels:
   
8.      name: neo4j
   
9.      
   
10. ---
    
11. 
    
12. apiVersion: apps/v1beta1
    
13. kind: StatefulSet
    
14. metadata:
    
15.   name: neo4j-core
    
16.   namespace: neo4j
    
17.   labels:
    
18.     app: neo4j-core
    
19. spec:
    
20.   replicas: 2    # 部署2个core-server
    
21.   selector:
    
22.     matchLabels:
    
23.       app: neo4j-core
    
24.   serviceName: neo4j-core
    
25.   template:
    
26.     metadata:
    
27.       labels:
    
28.         app: neo4j-core
    
29.     spec:
    
30.       containers:
    
31.       - name: neo4j-core
    
32.         image: neo4j:3.5.5-enterprise   # 官方镜像，3.5.5企业版
    
33.         imagePullPolicy: IfNotPresent
    
34.         env:    # 这里通过env，配置镜像环境参数，这是因为此镜像是通过这样来进行配置参数的
    
35.           - name: NEO4J_ACCEPT_LICENSE_AGREEMENT    # 接受证书协议，必须的
    
36.             value: "yes"
    
37.           - name: NEO4J_dbms_connectors_default__advertised__address  # 指定自身pod的ip地址，默认为localhost，在集群中必须注明自身地址，这里直接用ip
    
38.             valueFrom:
    
39.               fieldRef:
    
40.                 fieldPath: status.podIP
    
41.           - name: NEO4J_dbms_mode  # 节点的模式，选择CORE，就是核心节点
    
42.             value: "CORE"
    
43.           - name: NEO4J_AUTH   # 一定要自定义初始验证的用户名/密码
    
44.             value: "neo4j/your-password"
    
45.           - name: NEO4J_causal__clustering_minimum__core__cluster__size__at__formation
    
46.             value: "2"
    
47.           - name: NEO4J_causal__clustering_minimum__core__cluster__size__at__runtime
    
48.             value: "2"
    
49.           - name: NEO4J_causal__clustering_discovery__type  # 默认集群发现方式为LIST，这里写不写都行
    
50.             value: "LIST"
    
51.           - name: NEO4J_causal__clustering_initial__discovery__members  # 手动写明集群中所有成员的ip:port，5000端口为集群发现端口
    
52.             value: "neo4j-core-0.neo4j-core.neo4j.svc.cluster.local:5000,neo4j-core-1.neo4j-core.neo4j.svc.cluster.local:5000"
    
53.           - name: NEO4J_causal__clustering_discovery__advertised__address  # 下面这三个必须定义，为节点自身的ip:port，相当于节点自身的名称，因为默认是会用自身hostname，但是在k8s中，无法单单通过hostname解析到ip地址，这样定义的自身地址会无法识别
    
54.             value: $(NEO4J_dbms_connectors_default__advertised__address):5000
    
55.           - name: NEO4J_causalClustering_transactionAdvertisedAddress
    
56.             value: $(NEO4J_dbms_connectors_default__advertised__address):6000
    
57.           - name: NEO4J_causalClustering_raftAdvertisedAddress
    
58.             value: $(NEO4J_dbms_connectors_default__advertised__address):7000
    
59.         volumeMounts:
    
60.         - name: neo4j-core    # 挂载数据目录/data
    
61.           mountPath: /data
    
62.   volumeClaimTemplates:
    
63.   - metadata:
    
64.       name: neo4j-core  # 这里name要和上面volumeMounts的name一致，才能绑定到对应的pod
    
65.       annotations:
    
66.         volume.beta.kubernetes.io/storage-class: "managed-nfs-storage"  # 这里是上一步创建的nfs动态卷name
    
67.     spec:
    
68.       accessModes: [ "ReadWriteOnce" ]
    
69.       resources:
    
70.         requests:
    
71.           storage: 2Gi   # 大小自定义
    
72.          
    
73. ---
    
74. 
    
75. apiVersion: v1
    
76. kind: Service
    
77. metadata:
    
78.   name: neo4j-core
    
79.   namespace: neo4j
    
80. spec:
    
81.   selector:
    
82.     app: neo4j-core
    
83.   type: NodePort     # 这里用nodeport来开启外网访问，没用traefik是因为7687的连接端口不是http访问，需要4层负载，但是traefik不支持，所以只能通过nodeport来实现外网访问，才能正常访问7474端口的web管理界面。
    
84.   ports:
    
85.     - protocol: TCP
    
86.       name: http
    
87.       port: 7474
    
88.       nodePort: 27474
    
89.       targetPort: 7474
    
90.     - protocol: TCP
    
91.       name: blot
    
92.       port: 7687
    
93.       nodePort: 27687
    
94.       targetPort: 7687

复制代码

执行 yaml文件

1. kubectl create -f neo4j-core-server.yaml

复制代码

【注】

1. 1. 以上yaml文件中的注释要看清楚，因为 因果集群的核心节点是采用的选举方式来确定主节点的，所以最好是单数节点，我这里只部署了2个节点，只是因为资源不太够，测试而已，生产使用的话，最少3节点。
   
2. 2. 在这里，我用的默认的list的集群发现方式，有一点不好，就是如果增加节点，需要自己手动写上所有集群节点到列表中，且增加核心节点的时候，会比较麻烦。
   
3.     官方有三种发现方式，分别为LIST，DNS，K8S。    DNS的发现方式，可以通过在Service中，使用clusterIP:None 来取消负载的ip，然后在`NEO4J_causal__clustering_initial__discovery__members` 中设置为 `neo4j-core-0.neo4j-core.neo4j.svc.cluster.local:5000`，然后通过k8s集群中的dns服务，来解析到此Service中所有的ip。    这样配置非常方便，还不需要修改，没用是因为Service中，如果用了clusterIP:None 则没发使用nodeport来暴露7687的tcp端口给k8s外部网络使用，除非traefik可以实现tcp的4层负载，或者不是使用的traefik，二是nginx的Ingress，实现4层负载即可。    K8S的发现方式呢,由于文档没有示例的配置参考，不管怎么样设置，都还是无法正常启动，所以就没法用。
   
4. 3. 数据持久化存储，我这里用的nfs动态卷。
   
5. 4. 其中一定要自定义初始化的用户密码，因为neo4j的每个节点的用户验证系统是独立的！也就是说，你在leader节点上新增用户或修改密码，是不会同步到follower节点上的。所以，为了不至于当leader节点挂掉后，新的leader节点密码不同导致出错，部署时最好统一用户密码，当然只读节点也是。

复制代码

执行后，查看pod的日志，如下则为正常启动

部署只读节点READ-REPLICA
core核心节点部署完成后，则可以进行只读节点的部署，只读节点比核心节点则简单很多，创建neo4j-read-replica.yaml 文件

1. ---
   
2. apiVersion: apps/v1
   
3. kind: Deployment
   
4. metadata:
   
5.   name: neorj-read-replica
   
6.   namespace: neo4j
   
7.   labels:
   
8.     app: neorj-read-replica
   
9. spec:
   
10.   replicas: 3
    
11.   selector:
    
12.     matchLabels:
    
13.       app: neorj-read-replica
    
14.   template:
    
15.     metadata:
    
16.       labels:
    
17.         app: neorj-read-replica
    
18.     spec:
    
19.       containers:
    
20.       - name: neorj-read-replica
    
21.         image: neo4j:3.5.5-enterprise
    
22.         imagePullPolicy: IfNotPresent
    
23.         env:
    
24.           - name: NEO4J_ACCEPT_LICENSE_AGREEMENT
    
25.             value: "yes"
    
26.           - name: NEO4J_dbms_connectors_default__advertised__address
    
27.             valueFrom:
    
28.               fieldRef:
    
29.                 fieldPath: status.podIP
    
30.           - name: NEO4J_dbms_mode   # 指定模式为只读节点模式
    
31.             value: "READ_REPLICA"
    
32.           - name: NEO4J_AUTH
    
33.             value: "neo4j/your-password"   # 统一设置用户密码
    
34.           - name: NEO4J_causal__clustering_discovery__type
    
35.             value: "LIST"
    
36.           - name: NEO4J_causal__clustering_initial__discovery__members
    
37.             value: "neo4j-core-0.neo4j-core.neo4j.svc.cluster.local:5000,neo4j-core-1.neo4j-core.neo4j.svc.cluster.local:5000"
    
38.             
    
39. ---
    
40. 
    
41. apiVersion: v1
    
42. kind: Service
    
43. metadata:
    
44.   name: neorj-read-replica
    
45.   namespace: neo4j
    
46. spec:
    
47.   selector:
    
48.     app: neorj-read-replica
    
49.   ports:
    
50.   - protocol: TCP
    
51.     port: 7687
    
52.     targetPort: 7687

复制代码

执行此yaml文件，创建只读节点

1. kubectl create -f neo4j-read-replica.yaml

复制代码

【注】
部署3个只读节点，无状态服务，不需要进行数据持久化，只需要将core节点的集群列表写出就行了，会自动去找到核心节点的集群，然后从中复制数据，提供访问即可。
因为只读节点只能访问数据，所以没必要提供k8s的外部访问，所以直接在service中负载一下bolt的访问端口就行了，以提供给k8s内部应用访问即可。
查看日志如下为正常启动

访问WEB界面
部署完成后，设置域名，设置nginx，访问web界面
默认用户密码为： neo4j / neo4j
登录修改密码，然后查看状态，可以看到集群的状态

neo4j 3个成员组成的集群

为每个成员创建一个PersistentVolume
volume.sh

1. for i in $(seq 0 2); do
   
2.   cat <<EOF | kubectl create -f -
   
3. kind: PersistentVolume
   
4. apiVersion: v1
   
5. metadata:
   
6.   name: pv${i}
   
7.   labels:
   
8.     type: local
   
9.     app: neo4j
   
10. spec:
    
11.   capacity:
    
12.     storage: 1Gi
    
13.   accessModes:
    
14.     - ReadWriteOnce
    
15.   hostPath:
    
16.     path: "/tmp/${i}"
    
17. EOF
    
18.   cat <<EOF | kubectl create -f -
    
19. kind: PersistentVolumeClaim
    
20. apiVersion: v1
    
21. metadata:
    
22.   name: datadir-neo4j-${i}
    
23.   labels:
    
24.     app: neo4j
    
25. spec:
    
26.   accessModes:
    
27.     - ReadWriteOnce
    
28.   resources:
    
29.     requests:
    
30.       storage: 1Gi
    
31. EOF
    
32. done

复制代码

运行此脚本，它将创建3个卷

1. $ kubectl get pv
   
2. NAME      CAPACITY   ACCESSMODES   STATUS    CLAIM                     REASON    AGE
   
3. pv0       1Gi        RWO           Bound     default/datadir-neo4j-0             7s
   
4. pv1       1Gi        RWO           Bound     default/datadir-neo4j-1             7s
   
5. pv2       1Gi        RWO           Bound     default/datadir-neo4j-2             7s

复制代码

1. $ kubectl get pvc
   
2. NAME              STATUS    VOLUME    CAPACITY   ACCESSMODES   AGE
   
3. datadir-neo4j-0   Bound     pv0       1Gi        RWO           26s
   
4. datadir-neo4j-1   Bound     pv1       1Gi        RWO           26s
   
5. datadir-neo4j-2   Bound     pv2       1Gi        RWO           25s

复制代码

我们需要创建一个PetSet模板

1. # Headless service to provide DNS lookup
   
2. apiVersion: v1
   
3. kind: Service
   
4. metadata:
   
5.   labels:
   
6.     app: neo4j
   
7.   name: neo4j
   
8. spec:
   
9.   clusterIP: None
   
10.   ports:
    
11.     - port: 7474
    
12.   selector:
    
13.     app: neo4j
    
14. ----
    
15. # new API name
    
16. apiVersion: "apps/v1alpha1"
    
17. kind: PetSet
    
18. metadata:
    
19.   name: neo4j
    
20. spec:
    
21.   serviceName: neo4j
    
22.   replicas: 3
    
23.   template:
    
24.     metadata:
    
25.       annotations:
    
26.         pod.alpha.kubernetes.io/initialized: "true"
    
27.         pod.beta.kubernetes.io/init-containers: '[
    
28.             {
    
29.                 "name": "install",
    
30.                 "image": "gcr.io/google_containers/busybox:1.24",
    
31.                 "command": ["/bin/sh", "-c", "echo "
    
32.                 unsupported.dbms.edition=enterprise\n
    
33.                 dbms.mode=CORE\n
    
34.                 dbms.connectors.default_advertised_address=$HOSTNAME.neo4j.default.svc.cluster.local\n
    
35.                 dbms.connectors.default_listen_address=0.0.0.0\n
    
36.                 dbms.connector.bolt.type=BOLT\n
    
37.                 dbms.connector.bolt.enabled=true\n
    
38.                 dbms.connector.bolt.listen_address=0.0.0.0:7687\n
    
39.                 dbms.connector.http.type=HTTP\n
    
40.                 dbms.connector.http.enabled=true\n
    
41.                 dbms.connector.http.listen_address=0.0.0.0:7474\n
    
42.                 causal_clustering.raft_messages_log_enable=true\n
    
43.                 causal_clustering.initial_discovery_members=neo4j-0.neo4j.default.svc.cluster.local:5000,neo4j-1.neo4j.default.svc.cluster.local:5000,neo4j-2.neo4j.default.svc.cluster.local:5000\n
    
44.                 causal_clustering.leader_election_timeout=2s\n
    
45.                   " > /work-dir/neo4j.conf" ],
    
46.                 "volumeMounts": [
    
47.                     {
    
48.                         "name": "confdir",
    
49.                         "mountPath": "/work-dir"
    
50.                     }
    
51.                 ]
    
52.             }
    
53.         ]'
    
54.       labels:
    
55.         app: neo4j
    
56.     spec:
    
57.       containers:
    
58.       - name: neo4j
    
59.         image: "neo4j/neo4j-experimental:3.1.0-M13-beta3-enterprise"
    
60.         imagePullPolicy: Always
    
61.         ports:
    
62.         - containerPort: 5000
    
63.           name: discovery
    
64.         - containerPort: 6000
    
65.           name: tx
    
66.         - containerPort: 7000
    
67.           name: raft
    
68.         - containerPort: 7474
    
69.           name: browser
    
70.         - containerPort: 7687
    
71.           name: bolt
    
72.         securityContext:
    
73.           privileged: true
    
74.         volumeMounts:
    
75.         - name: datadir
    
76.           mountPath: /data
    
77.         - name: confdir
    
78.           mountPath: /conf
    
79.       volumes:
    
80.       - name: confdir
    
81.   volumeClaimTemplates:
    
82.   - metadata:
    
83.       name: datadir
    
84.       annotations:
    
85.         volume.alpha.kubernetes.io/storage-class: anything
    
86.     spec:
    
87.       accessModes: [ "ReadWriteOnce" ]
    
88.       resources:
    
89.         requests:
    
90.           storage: 2Gi

复制代码

创建PetSet

1. $ kubectl create -f neo4j.yaml
   
2. service "neo4j" created
   
3. petset "neo4j" created

复制代码

检查Pod是否已启动并正在运行

1. $ kubectl get pods
   
2. NAME      READY     STATUS    RESTARTS   AGE
   
3. neo4j-0   1/1       Running   0          2m
   
4. neo4j-1   1/1       Running   0          14s
   
5. neo4j-2   1/1       Running   0          10s

复制代码

neo4j的日志文件

1. $ kubectl logs neo4j-0
   
2. Starting Neo4j.
   
3. 2016-11-25 16:39:50.333+0000 INFO  Starting...
   
4. 2016-11-25 16:39:51.723+0000 INFO  Bolt enabled on 0.0.0.0:7687.
   
5. 2016-11-25 16:39:51.733+0000 INFO  Initiating metrics...
   
6. 2016-11-25 16:39:51.911+0000 INFO  Waiting for other members to join cluster before continuing...
   
7. 2016-11-25 16:40:12.074+0000 INFO  Started.
   
8. 2016-11-25 16:40:12.428+0000 INFO  Mounted REST API at: /db/manage
   
9. 2016-11-25 16:40:13.350+0000 INFO  Remote interface available at http://neo4j-0.neo4j.default.svc.cluster.local:7474/

复制代码

1. $ kubectl logs neo4j-1
   
2. Starting Neo4j.
   
3. 2016-11-25 16:39:53.846+0000 INFO  Starting...
   
4. 2016-11-25 16:39:56.212+0000 INFO  Bolt enabled on 0.0.0.0:7687.
   
5. 2016-11-25 16:39:56.225+0000 INFO  Initiating metrics...
   
6. 2016-11-25 16:39:56.341+0000 INFO  Waiting for other members to join cluster before continuing...
   
7. 2016-11-25 16:40:16.623+0000 INFO  Started.
   
8. 2016-11-25 16:40:16.951+0000 INFO  Mounted REST API at: /db/manage
   
9. 2016-11-25 16:40:17.607+0000 INFO  Remote interface available at http://neo4j-1.neo4j.default.svc.cluster.local:7474/

复制代码

1. $ kubectl logs neo4j-2
   
2. Starting Neo4j.
   
3. 2016-11-25 16:39:57.828+0000 INFO  Starting...
   
4. 2016-11-25 16:39:59.166+0000 INFO  Bolt enabled on 0.0.0.0:7687.
   
5. 2016-11-25 16:39:59.176+0000 INFO  Initiating metrics...
   
6. 2016-11-25 16:39:59.329+0000 INFO  Waiting for other members to join cluster before continuing...
   
7. 2016-11-25 16:40:19.216+0000 INFO  Started.
   
8. 2016-11-25 16:40:19.675+0000 INFO  Mounted REST API at: /db/manage
   
9. 2016-11-25 16:40:21.029+0000 INFO  Remote interface available at http://neo4j-2.neo4j.default.svc.cluster.local:7474/

复制代码

为每个服务器设置了端口转发

1. $ kubectl port-forward neo4j-0 27474:7474 27687:7687

复制代码

运行以下过程来获得集群的概述

1. CALL dbms.cluster.overview()
   
2. ╒════════════════════════════════════╤══════════════════════════════════════════════════════╤════════╕
   
3. │id                                  │addresses                                             │role    │
   
4. ╞════════════════════════════════════╪══════════════════════════════════════════════════════╪════════╡
   
5. │81d8e5e2-02db-4414-85de-a7025b346e84│[bolt://neo4j-0.neo4j.default.svc.cluster.local:27687,│LEADER  │
   
6. │                                    │ http://neo4j-0.neo4j.default.svc.cluster.local:27474]│        │
   
7. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
   
8. │347b7517-7ca0-4b92-b9f0-9249d46b2ad3│[bolt://neo4j-1.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
   
9. │                                    │ http://neo4j-1.neo4j.default.svc.cluster.local:27474]│        │
   
10. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
    
11. │a5ec1335-91ce-4358-910b-8af9086c2969│[bolt://neo4j-2.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
    
12. │                                    │ http://neo4j-2.neo4j.default.svc.cluster.local:27474]│        │
    
13. └────────────────────────────────────┴──────────────────────────────────────────────────────┴────────┘

复制代码

如果 希望集群中有5台服务器而不是3台，运行以下命令来增加副本的大小

1. $ kubectl patch petset neo4j -p '{"spec":{"replicas":5}}'
   
2. "neo4j" patched

复制代码

再次运行该过程

1. CALL dbms.cluster.overview()
   
2. ╒════════════════════════════════════╤══════════════════════════════════════════════════════╤════════╕
   
3. │id                                  │addresses                                             │role    │
   
4. ╞════════════════════════════════════╪══════════════════════════════════════════════════════╪════════╡
   
5. │81d8e5e2-02db-4414-85de-a7025b346e84│[bolt://neo4j-0.neo4j.default.svc.cluster.local:27687,│LEADER  │
   
6. │                                    │ http://neo4j-0.neo4j.default.svc.cluster.local:27474]│        │
   
7. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
   
8. │347b7517-7ca0-4b92-b9f0-9249d46b2ad3│[bolt://neo4j-1.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
   
9. │                                    │ http://neo4j-1.neo4j.default.svc.cluster.local:27474]│        │
   
10. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
    
11. │a5ec1335-91ce-4358-910b-8af9086c2969│[bolt://neo4j-2.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
    
12. │                                    │ http://neo4j-2.neo4j.default.svc.cluster.local:27474]│        │
    
13. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
    
14. │28613d06-d4c5-461c-b277-ddb3f05e5647│[bolt://neo4j-3.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
    
15. │                                    │ http://neo4j-3.neo4j.default.svc.cluster.local:27474]│        │
    
16. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
    
17. │2eaa0058-a4f3-4f07-9f22-d310562ad1ec│[bolt://neo4j-4.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
    
18. │                                    │ http://neo4j-4.neo4j.default.svc.cluster.local:27474]│        │
    
19. └────────────────────────────────────┴──────────────────────────────────────────────────────┴────────┘

复制代码

再次回到3很简单

1. $ kubectl patch petset neo4j -p '{"spec":{"replicas":3}}'
   
2. "neo4j" patched

复制代码

1. CALL dbms.cluster.overview()
   
2. ╒════════════════════════════════════╤══════════════════════════════════════════════════════╤════════╕
   
3. │id                                  │addresses                                             │role    │
   
4. ╞════════════════════════════════════╪══════════════════════════════════════════════════════╪════════╡
   
5. │81d8e5e2-02db-4414-85de-a7025b346e84│[bolt://neo4j-0.neo4j.default.svc.cluster.local:27687,│LEADER  │
   
6. │                                    │ http://neo4j-0.neo4j.default.svc.cluster.local:27474]│        │
   
7. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
   
8. │347b7517-7ca0-4b92-b9f0-9249d46b2ad3│[bolt://neo4j-1.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
   
9. │                                    │ http://neo4j-1.neo4j.default.svc.cluster.local:27474]│        │
   
10. ├────────────────────────────────────┼──────────────────────────────────────────────────────┼────────┤
    
11. │a5ec1335-91ce-4358-910b-8af9086c2969│[bolt://neo4j-2.neo4j.default.svc.cluster.local:27687,│FOLLOWER│
    
12. │                                    │ http://neo4j-2.neo4j.default.svc.cluster.local:27474]│        │
    
13. └────────────────────────────────────┴──────────────────────────────────────────────────────┴────────┘

复制代码

托管Kubernetes上部署Neo4J单核

1. cd /tmp/  git clone https: //github.com/sdaschner/neo4j-helm --branch single-instance  cd neo4j-helm/  helm template graphdb \
   
2.    --set acceptLicenseAgreement=yes \
   
3.    --set neo4jPassword=mySecretPassword . \
   
4.    > /tmp/neo4j.yaml  kubectl apply -f /tmp/neo4j.yaml

复制代码

总结

到此这篇关于Docker安装部署neo4j的文章就介绍到这了,更多相关Docker安装部署neo4j内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/article/284056.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！