安装

1.使用ZIP压缩包安装

1.1.环境要求

Apache Ignite官方在如下环境中进行了测试：

JDK：Oracle JDK8及11，Open JDK8及11，IBM JDK8及11；
OS：Linux（任何版本），Mac OS X（10.6及以上），Windows(XP及以上)，Windows Server（2008及以上），Oracle Solaris；
网络：没有限制（建议10G甚至更快的网络带宽）；
架构：x86，x64，SPARC，PowerPC。

1.2.使用ZIP压缩包安装

Ignite入门的最简单方式是使用每次版本发布生成的二进制压缩包：

下载最新版本的Ignite压缩包；
将该包解压到操作系统的一个文件夹；
（可选）启用必要的模块；
（可选）配置IGNITE_HOME环境变量或者Windows的PATH指向Ignite的安装文件夹，路径不要以/（Windows为\）结尾。

2.使用Docker安装

2.1.注意事项

内存集群和持久化集群

在部署开启持久化的Ignite集群时，需要加载一个持久化卷或者本地目录。如果没有使用持久化卷，Ignite会将数据保存在容器内的文件系统，这意味着如果删除容器，数据也会丢失。

网络

Ignite的Docker镜像默认会暴露如下的端口：11211、47100、47500、49112。通过给docker run命令添加-p <port>参数，可以暴露更多的端口，比如要使用瘦客户端接入在容器中运行的Ignite节点，需要打开10800端口：

shell

docker run -d -p 10800:10800 apacheignite/ignite

2.2.下载Ignite的Docker镜像

假定主机上已经安装好了Docker，那么可以使用如下命令拉取并运行Ignite的Docker镜像。

打开命令行终端，使用如下命令拉取Ignite的Docker镜像：

shell

# Pull latest version
sudo docker pull apacheignite/ignite

默认会下载最新的版本，但是也可以下载指定的版本：

shell

# Pull a specific Ignite version
sudo docker pull apacheignite/ignite:2.10.0

2.3.运行内存集群

在Docker容器中运行Ignite，需要使用docker run命令：

shell

# Run the latest version
sudo docker run -d apacheignite/ignite

该命令会启动单个Ignite节点。

使用如下命令，可以启动指定版本的Ignite：

shell

# Run a specific Ignite version
sudo docker run -d apacheignite/ignite:2.10.0

2.4.运行持久化集群

如果使用原生持久化，Ignite会将用户数据保存在容器文件系统的默认工作目录中（{IGNITE_HOME}/work），如果重启容器，该目录会被删除，未来避免这个问题，可以这样做：

使用一个持久化卷来保存数据；
加载一个本地目录。

2.4.1.使用持久化卷

使用如下命令可以创建一个持久化卷：

shell

sudo docker volume create persistence-volume

运行Ignite的Docker镜像时可以将这个卷加载到一个指定的目录，该目录可以通过两个方式传给Ignite：

使用IGNITE_WORK_DIR系统属性；
在节点配置文件中指定。

如下命令会启动一个Ignite的Docker镜像，通过系统属性将工作目录传给Ignite：

shell

docker run -d \
 -v storage-volume:/storage \
 -e IGNITE_WORK_DIR=/storage \
 apacheignite/ignite

2.4.2.使用本地目录

如果不创建持久化卷，还可以将一个本地目录加载到运行Ignite镜像的容器，Ignite会使用这个目录来保存持久化数据。当使用同一个命令重启容器后，Ignite会从该目录加载数据。

shell

mkdir work_dir

docker run -d \
  -v ${PWD}/work_dir:/storage \
  -e IGNITE_WORK_DIR=/storage \
  apacheignite/ignite

-v选项会将一个本地目录加载到容器的/storage路径下面，-e IGNITE_WORK_DIR=/storage选项会通知Ignite将该文件夹用作工作目录。

2.5.提供配置文件

运行镜像时，会使用默认的配置文件启动节点，但可以通过CONFIG_URI环境变量传递一个自定义的配置文件：

shell

docker run -d \
  -e CONFIG_URI=http://myserver/config.xml  \
  apacheignite/ignite

还可以使用来自本地文件系统中的一个文件，首先要使用-v选项将该文件加载到容器中的特定路径，然后在CONFIG_URI中使用这个路径：

shell

docker run -d \
  -v /local/dir/config.xml:/config-file.xml \
  -e CONFIG_URI=/config-file.xml \
  apacheignite/ignite

2.6.部署自己的库文件

启动节点时，会将{IGNITE_HOME}/libs下面发现的所有库文件（忽略optional目录）都加载到类路径中，如果希望部署自己的库文件，可以通过-v选项，将本地主机上的一个目录加载到容器中/opt/ignite/apache-ignite/libs/下面的某个路径上。

如下命令会将主机上的一个目录加载到容器的libs/user_libs，该目录下的所有库文件都会加载到节点的类路径中：

shell

docker run -v /local_path/to/dir_with_libs/:/opt/ignite/apache-ignite/libs/user_libs apacheignite/ignite

如果库文件可以通过URL进行访问，另一个选项是使用EXTERNAL_LIBS变量：

shell

docker run -e "EXTERNAL_LIBS=http://url_to_your_jar" apacheignite/ignite

2.7.启用模块

要启用某模块，可以在OPTION_LIBS系统变量中指定他们的名字，如下所示：

shell

sudo docker run -d \
  -e "OPTION_LIBS=ignite-rest-http,ignite-aws" \
  apacheignite/ignite

Ignite的Docker镜像默认会启用下面的模块：

ignite-log4j；
ignite-spring；
ignite-indexing。

2.8.环境变量

下面的参数可以以环境变量的形式传给Docker容器：

名称	描述	默认
`CONFIG_URI`	Ignite配置文件的URL（也可以相对于类路径的META-INF文件夹），下载的配置文件会保存于`./ignite-config.xml`	无
`OPTION_LIBS`	会被包含在类路径中的可选库	`ignite-log4j, ignite-spring,ignite-indexing`
`JVM_OPTS`	传递给Ignite实例的JVM参数。	无
`EXTERNAL_LIBS`	库文件URL列表	无

3.使用DEB/RPM包安装

3.1.概述

Ignite可以通过RPM或者DEB仓库进行安装。

确认Linux发行版

Ignite的RPM/DEB包，在如下的Linux发行版中进行了验证：

Ubuntu 14.10及以上的版本；
Debian 9.3及以上的版本；
CentOS 7.4.1708及以上的版本

只要包可以安装，其它的发行版也是支持的。

3.2.仓库的配置

配置Ignite的RPM或者DEB仓库，如下所示（如果必要，需要根据提示接受GPG密钥），其中包括了特定发行版的配置：

Debian：

bash

# Install dirmngr (if not already installed) for apt-key ability to retrieve remote GPG keys
sudo apt update
sudo apt install dirmngr --no-install-recommends

RPMDEB

bash

sudo bash -c 'cat <<EOF > /etc/yum.repos.d/ignite.repo
[ignite]
name=Apache Ignite
baseurl=http://apache.org/dist/ignite/rpm/
gpgcheck=1
repo_gpgcheck=1
gpgkey=http://apache.org/dist/ignite/KEYS
       http://bintray.com/user/downloadSubjectPublicKey?username=bintray
EOF'
sudo yum check-update

bash

sudo bash -c 'cat <<EOF > /etc/apt/sources.list.d/ignite.list
deb http://apache.org/dist/ignite/deb/ apache-ignite main
EOF'
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 379CE192D401AB61
sudo apt update

3.3.Ignite的安装

安装Ignite的最新版：

RPMDEB

bash

sudo yum install apache-ignite

bash

sudo apt install apache-ignite --no-install-recommends

安装后的结构如下：

文件夹	映射至	描述
`/usr/share/apache-ignite`		Ignite安装的根目录
`/usr/share/apache-ignite/bin`		二进制文件文件夹（脚本以及可执行程序）
`/etc/apache-ignite`	`/usr/share/apache-ignite/config`	默认配置文件
`/var/log/apache-ignite`	`/var/lib/apache-ignite/log`	日志目录
`/usr/lib/apache-ignite`	`/usr/share/apache-ignite/libs`	核心和可选库
`/var/lib/apache-ignite`	`/usr/share/apache-ignite/work`	Ignite的工作目录
`/usr/share/doc/2.10.0/apache-ignite`		文档
`/usr/share/license/apache-ignite-<version>`		协议
`/etc/systemd/system`		`systemd`服务配置

3.4.将Ignite作为服务

注意

如果运行于Windows10 WSL或者Docker，那么需要将Ignite作为一个独立的进程（而不是一个服务），具体可以看下面的章节。

用一个配置文件启动一个Ignite节点，可以这样做：sudo systemctl start apache-ignite@<config_name>，注意这里的<config_name>参数是相对于/etc/apache-ignite文件夹的。

运行Ignite服务：

bash

sudo systemctl start apache-ignite@default-config.xml    # start Ignite service
journalctl -fe                                           # check logs

如果要开启随着系统启动而节点自动重启，如下：

bash

sudo systemctl enable apache-ignite@<config name>

3.5.将Ignite作为独立进程

使用下面的命令可以将Ignite启动为一个独立的进程（先要切换到/usr/share/apache-ignite），如果要修改默认的配置，可以修改/etc/apache-ignite/default-config.xml文件。默认的配置会使用组播IP探测器，如果要使用静态IP探测器，需要修改默认的配置文件，具体参见TCP/IP发现。

首先，切换到ignite用户，如下：

bash

sudo -u ignite /usr/bin/env bash    # switch to ignite user

然后切换到Ignite的bin文件夹，启动一个节点：

默认配置自定义配置

bash

cd /usr/share/apache-ignite         # navigate to Ignite home folder
bin/ignite.sh                       # run Ignite with default configuration

bash

sudo -u ignite /usr/bin/env bash       # switch to ignite user
cd /usr/share/apache-ignite/bin        # navigate to Ignite bin folder
./ignite.sh <path_to_custom_config>    # start Ignite with custom configuration

3.6.在Windows10 WSL中运行Ignite

网络配置

在Windows 10 WSL环境下运行Ignite，需要对具有高级安全的Windows防御防火墙进行正确的配置：

运行具有高级安全的Windows防御防火墙；
选择左侧的入站规则菜单；
选择右侧的新建规则菜单；
选择程序复选框然后点击下一步；
在程序路径字段中输入%SystemRoot%\System32\wsl.exe，然后点击下一步；
选择允许连接复选框，然后点击下一步；
选择域、私有和公开复选框，然后点击下一步；
在名字字段中输入名字（在描述字段中，也可以可选地写一段描述），然后点击完成。

这个配置好的规则将允许Windows 10 WSL环境中的Ignite节点暴露于局域网中。

启动Ignite集群

由于特殊的网络堆栈实现，如果要在一个Windows10 WSL环境中运行多个节点，需要对配置进行自定义（可以看下面的wsl-default-config），启动命令如下：bin/ignite.sh config/wsl-default-config.xml -J-DNODE=<00..99>。

wsl-default-config.xml：

xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="placeholderConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"/>

    <bean id="ignite.cfg" class="org.apache.ignite.configuration.IgniteConfiguration">
        <property name="discoverySpi">
            <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
                <property name="localPort" value="475${NODE}"/>
                <property name="ipFinder">
                    <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.multicast.TcpDiscoveryMulticastIpFinder">
                        <property name="addresses">
                            <list>
                                <value>127.0.0.1:47500..47599</value>
                            </list>
                        </property>
                    </bean>
                </property>
            </bean>
        </property>

        <property name="communicationSpi">
            <bean class="org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi">
                <property name="localPort" value="481${NODE}"/>
            </bean>
        </property>

    </bean>
</beans>

首先，以ignite用户登录，如下：

bash

sudo -u ignite /usr/bin/env bash

然后转到Ignite的主文件夹，然后在本地启动希望数量的节点（最多100）：

bash

# Navigate to Ignite home folder
cd /usr/share/apache-ignite

# Run several local nodes
bin/ignite.sh config/wsl-default-config.xml -J-DNODE=00 &
bin/ignite.sh config/wsl-default-config.xml -J-DNODE=01 &
...
bin/ignite.sh config/wsl-default-config.xml -J-DNODE=99 &

4.Kubernetes

4.1.Kubernetes部署

Ignite集群可以容易地在Kubernetes环境中部署和维护，Kubernetes是一个开源的系统，可以自动化地部署、伸缩以及管理容器化的应用。

本章节会引导用户将Ignite部署进Kubernetes环境，还会涉及一些与Ignite有关的特殊性内容。

首先要确定Ignite的开发和使用方式：

如果使用纯内存方式或者作为第三方数据库（RDBMS, NoSQL）的缓存层，那么需要遵照无状态部署的相关文档；
如果Ignite作为内存数据库，并且开启了持久化，那么需要遵照有状态部署的相关文档。

4.2.常规配置

4.2.1.无状态部署

如果使用纯内存方式或者作为第三方数据库（RDBMS, NoSQL）的缓存层，那么需要将其按照无状态的解决方案进行部署。

4.2.1.1.要求

确保如下事项已经完成：

环境中已经部署了Kubernetes集群；
已经配置了RBAC授权；
已经部署了Ignite服务；

4.2.1.2.Kubernetes IP探测器

要开启Kubernetes环境下Ignite节点的自动发现，需要在IgniteConfiguration中启用TcpDiscoveryKubernetesIpFinder，下面会创建一个名为example-kube-rbac.xml的配置文件，然后像下面这样定义相关的配置：

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util.xsd">

<bean class="org.apache.ignite.configuration.IgniteConfiguration">
  <property name="discoverySpi">
    <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
      <property name="ipFinder">
         <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.kubernetes.TcpDiscoveryKubernetesIpFinder">
           <property name="namespace" value="ignite"/>
         </bean>
      </property>
    </bean>
  </property>
</bean>
</beans>

下面，就可以为Ignite Pod准备一套Kubernetes环境然后部署了。

4.2.1.3.Ignite Pod部署

最后，需要为Ignite Pod定义一个yaml格式配置文件。

ignite-deployment.yaml：

yaml

# An example of a Kubernetes configuration for Ignite pods deployment.
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  # Custom Ignite cluster's name.
  name: ignite-cluster
spec:
  # A number of Ignite pods to be started by Kubernetes initially.
  replicas: 2
  template:
    metadata:
      labels:
        app: ignite
    spec:
      containers:
        # Custom Ignite pod name.
      - name: ignite-node
        image: apacheignite/ignite:2.5.0
        env:
        - name: OPTION_LIBS
          value: ignite-kubernetes
        - name: CONFIG_URI
          value: https://raw.githubusercontent.com/apache/ignite/master/modules/kubernetes/config/example-kube-persistence.xml
        ports:
        # Ports to open.
        # Might be optional depending on your Kubernetes environment.
        - containerPort: 11211 # REST port number.
        - containerPort: 47100 # communication SPI port number.
        - containerPort: 47500 # discovery SPI port number.
        - containerPort: 49112 # JMX port number.
        - containerPort: 10800 # SQL port number.
        - containerPort: 10900 # Thin clients port number.

如上所示，该配置定义了一组环境变量（OPTION_LIBS和CONFIG_URIL），Ignite的Docker镜像使用的一个shell脚本会用到它。Docker镜像的完整配置参数列表可以查看Docker部署的相关章节。

Ignite Docker镜像版本

Kubernetes支持Ignite的1.9及其以后的版本，一定要使用有效的Docker镜像版本，完整的标签列表在这里。

下一步，在Kubernetes中使用上述的配置部署Ignite Pod：

bash

kubectl create -f ignite-deployment.yaml

检查Pod是否启动运行：

bash

kubectl get pods

选择一个可用的Pod的名字：

NAME                              READY     STATUS    RESTARTS   AGE
ignite-cluster-3454482164-d4m6g   1/1       Running   0          25m
ignite-cluster-3454482164-w0xtx   1/1       Running   0          25m

可以获取日志，确认Pod之间可以在集群内相互发现：

bash

kubectl logs ignite-cluster-3454482164-d4m6g

4.2.1.4.调整Ignite集群大小

可以使用标准的Kubernetes API随时调整Ignite集群的大小。比如，如果想把集群从2个节点扩容到5个节点，那么可以使用下面的命令：

bash

kubectl scale --replicas=5 -f ignite-deployment.yaml

再次检查集群已经成功扩容：

bash

kubectl get pods

输出会显示有5个Pod正在运行：

NAME                              READY     STATUS    RESTARTS   AGE
ignite-cluster-3454482164-d4m6g   1/1       Running   0          34m
ignite-cluster-3454482164-ktkrr   1/1       Running   0          58s
ignite-cluster-3454482164-r20f8   1/1       Running   0          58s
ignite-cluster-3454482164-vf8kh   1/1       Running   0          58s
ignite-cluster-3454482164-w0xtx   1/1       Running   0          34m

4.2.1.5.在OpenShift环境中部署

对于使用Docker容器的Kubernetes，OpenShift也是支持的，但是它有自己的RBAC（基于角色的访问控制）特性，这与Kubernetes直接提供的机制不完全兼容，这也是为什么部分命令会导致拒绝访问错误的原因，这时就需要一些额外的配置，如下：

1.使用OpenShift的CLI创建一个具有view角色的服务账户；

bash

$ oc create sa ignite
$ oc policy add-role-to-user view system:serviceaccount:<project>:ignite

注意，<project>是OpenShift的项目名。 2.指定TcpDiscoveryKubernetesIpFinder的namespace参数；

xml

<bean id="ignite.cfg" class="org.apache.ignite.configuration.IgniteConfiguration">
    <property name="discoverySpi">
        <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
            <property name="ipFinder">
                <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.kubernetes.TcpDiscoveryKubernetesIpFinder">
                    <!-- Set a project name as the namespace. -->
                    <property name="namespace" value="<project>"/>
                </bean>
            </property>
        </bean>
    </property>
</bean>

3.在部署配置中添加serviceAccountName；

yaml

apiVersion: v1
kind: DeploymentConfig
metadata:
  name: ignite-cluster
spec:
  # Start two Ignite nodes by default.
  replicas: 2
  template:
    metadata:
      labels:
        app: ignite
    spec:
      serviceAccountName: ignite
    ...

4.2.2.有状态部署

如果Ignite部署为内存数据库，并且打开了原生持久化，那么就需要按照有状态的解决方案进行部署。

4.2.2.1.要求

确保如下事项已经完成

环境中已经部署了Kubernetes集群；
已经配置了RBAC授权；
已经部署了Ignite服务；

4.2.2.2.Kubernetes IP探测器

要开启Kubernetes环境下Ignite节点的自动发现，需要在IgniteConfiguration中启用TcpDiscoveryKubernetesIpFinder，下面会创建一个名为example-kube-persistence.xml的配置文件，然后像下面这样定义相关的配置：

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:util="http://www.springframework.org/schema/util" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/util         http://www.springframework.org/schema/util/spring-util.xsd">
    <bean class="org.apache.ignite.configuration.IgniteConfiguration">
        <property name="workDirectory" value="/persistence/work"/>
        <!-- Enabling Apache Ignite Persistent Store. -->
        <property name="dataStorageConfiguration">
            <bean class="org.apache.ignite.configuration.DataStorageConfiguration">
                <property name="defaultDataRegionConfiguration">
                    <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
                        <property name="persistenceEnabled" value="true"/>
                    </bean>
                </property>
                <!--
                   Sets a path to the root directory where data and indexes are
                   to be persisted. It's assumed the directory is on a dedicated disk.
                -->
                <property name="storagePath" value="/persistence"/>
                <!--
                    Sets a path to the directory where WAL is stored.
                    It's assumed the directory is on a dedicated disk.
                -->
                <property name="walPath" value="/wal"/>
                <!--
                    Sets a path to the directory where WAL archive is stored.
                    It's assumed the directory is on the same drive with the WAL files.
                -->
                <property name="walArchivePath" value="/wal/archive"/>
            </bean>
        </property>

        <!-- Explicitly configure TCP discovery SPI to provide list of initial nodes. -->
        <property name="discoverySpi">
            <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
                <property name="ipFinder">
                    <!--
                    Enables Kubernetes IP finder and setting custom namespace name.
                    -->
                    <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.kubernetes.TcpDiscoveryKubernetesIpFinder">
                        <property name="namespace" value="ignite"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

该配置开启了Ignite的原生持久化，确保数据能够保存在磁盘上。

下面，就可以为Ignite Pod准备一套Kubernetes有状态集配置然后部署了。

4.2.2.3.有状态集部署

最后一步是以有状态集的形式在Kubernetes中部署Ignite Pod。

建议为预写日志文件（WAL）和数据库文件提供单独的磁盘设备，以获得更好的性能。这就是为什么本节提供了两种部署方案的说明：当WAL和数据库文件位于同一个存储中以及分别存储时。

有状态集部署时间

Kubernetes环境可能需要一段时间来分配需要的持久化存储，从而成功地部署所有Pod。在分配时，Pod的部署状态可能会显示如下消息：“pod has unbound persistentvolumeclaims（repeated 4 times）”。

WAL使用独立磁盘

为了确保WAL存储在不同的磁盘上，需要求Kuberenetes提供一个专用的存储类。依赖于Kubernetes环境，存储类将有所不同。在本章节中会为Amazon AWS、Google Compute Engine和Microsoft Azure提供存储类模板。

使用以下模板为WAL请求存储类：

ignite-wal-storage-class.yaml：

AWSGCEAzure

yaml

#Amazon AWS Configuration
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ignite-wal-storage-class  #StorageClass name
  namespace: ignite #Ignite namespace
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp2 #Volume type io1, gp2, sc1, st1. Default: gp2
  zones: us-east-1d

yaml

#Google Compute Engine Configuration
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ignite-wal-storage-class #StorageClass Name
  namespace: ignite #Ignite namespace
provisioner: kubernetes.io/gce-pd
parameters:
  type: pd-standard #Volume type pd-standard or pd-ssd. Default: pd-standard
  zones: europe-west1-b
  replication-type: none

yaml

#Microsoft Azure Configuration
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ignite-wal-storage-class  #StorageClass name
  namespace: ignite #Ignite namespace
provisioner: kubernetes.io/azure-disk
parameters:
  storageaccounttype: Standard_LRS
  kind: managed

通过执行以下命令为WAL文件请求存储：

bash

#Request storage class
kubectl create -f ignite-wal-storage-class.yaml

执行类似的操作，为数据库文件请求专用存储类：

ignite-persistence-storage-class.yaml：

AWSGCEAzure

yaml

#Amazon AWS Configuration
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ignite-persistence-storage-class  #StorageClass name
  namespace: ignite         #Ignite namespace
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp2 #Volume type io1, gp2, sc1, st1. Default: gp2
  zones: us-east-1d

yaml

#Google Compute Engine configuration
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ignite-persistence-storage-class  #StorageClass Name
  namespace: ignite         #Ignite namespace
provisioner: kubernetes.io/gce-pd
parameters:
  type: pd-standard #Type pd-standard or pd-ssd. Default: pd-standard
  zones: europe-west1-b
  replication-type: none

yaml

#Microsoft Azure Configuration
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ignite-persistence-storage-class  #StorageClass name
  namespace: ignite #Ignite namespace
provisioner: kubernetes.io/azure-disk
parameters:
  storageaccounttype: Standard_LRS
  kind: managed

通过执行以下命令为数据库文件请求存储：

bash

#Request storage class
kubectl create -f ignite-persistence-storage-class.yaml

存储类参数

可以根据需要自由调整存储类配置的区域、存储类型和其它参数。

确认两个存储类都已创建并可使用：

bash

kubectl get sc

接下来，继续在Kubernetes中部署有状态集：

yaml

apiVersion: apps/v1beta2
kind: StatefulSet
metadata:
  name: ignite
  namespace: ignite
spec:
  selector:
    matchLabels:
      app: ignite
  serviceName: ignite
  replicas: 2
  template:
    metadata:
      labels:
        app: ignite
    spec:
      serviceAccountName: ignite
      containers:
      - name: ignite
        image: apacheignite/ignite:2.6.0
        env:
        - name: OPTION_LIBS
          value: ignite-kubernetes,ignite-rest-http
        - name: CONFIG_URI
          value: https://raw.githubusercontent.com/apache/ignite/master/modules/kubernetes/config/example-kube-persistence-and-wal.xml
        - name: IGNITE_QUIET
          value: "false"
        - name: JVM_OPTS
          value: "-Djava.net.preferIPv4Stack=true"
        ports:
        - containerPort: 11211 # JDBC port number.
        - containerPort: 47100 # communication SPI port number.
        - containerPort: 47500 # discovery SPI port number.
        - containerPort: 49112 # JMX port number.
        - containerPort: 10800 # SQL port number.
        - containerPort: 8080 # REST port number.
        - containerPort: 10900 #Thin clients port number.
        volumeMounts:
        - mountPath: "/wal"
          name: ignite-wal
        - mountPath: "/persistence"
          name: ignite-persistence
  volumeClaimTemplates:
  - metadata:
      name: ignite-persistence
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "ignite-persistence-storage-class"
      resources:
        requests:
          storage: "1Gi"
  - metadata:
      name: ignite-wal
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "ignite-wal-storage-class"
      resources:
        requests:
          storage: "1Gi"

bash

# Create the stateful set
kubectl create -f ignite-stateful-set.yaml

确认Ignite Pod正在运行：

bash

kubectl get pods --namespace=ignite

数据库和WAL文件使用相同的存储

如果出于某种原因，需要将WAL和数据库文件存储在同一个磁盘设备中，那么可以使用下面的配置模板来部署和启动有状态集：

ignite-stateful-set.yaml：

yaml

apiVersion: apps/v1beta2
kind: StatefulSet
metadata:
  name: ignite
  namespace: ignite
spec:
  selector:
    matchLabels:
      app: ignite
  serviceName: ignite
  replicas: 2
  template:
    metadata:
      labels:
        app: ignite
    spec:
      serviceAccountName: ignite
      containers:
      - name: ignite
        image: apacheignite/ignite:2.6.0
        env:
        - name: OPTION_LIBS
          value: ignite-kubernetes,ignite-rest-http
        - name: CONFIG_URI
          value: https://raw.githubusercontent.com/apache/ignite/master/modules/kubernetes/config/example-kube-persistence.xml
        - name: IGNITE_QUIET
          value: "false"
        - name: JVM_OPTS
          value: "-Djava.net.preferIPv4Stack=true"
        ports:
        - containerPort: 11211 # JDBC port number.
        - containerPort: 47100 # communication SPI port number.
        - containerPort: 47500 # discovery SPI port number.
        - containerPort: 49112 # JMX port number.
        - containerPort: 10800 # SQL port number.
        - containerPort: 8080 # REST port number.
        - containerPort: 10900 #Thin clients port number.
        volumeMounts:
        - mountPath: "/data/ignite"
          name: ignite-storage
  volumeClaimTemplates:
  - metadata:
      name: ignite-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

bash

# Create the stateful set
kubectl create -f ignite-stateful-set.yaml

如上所示，该配置定义了一组环境变量（OPTION_LIBS和CONFIG_URI），Ignite的Docker镜像使用的一个shell脚本会用到它。Docker镜像的完整配置参数列表可以查看Docker部署的相关章节。

确认Ignite的Pod已经启动运行：

bash

kubectl get pods --namespace=ignite

获取Ignite Pod的日志

通过下面的过程，可以获取Ignite的Pod生成的日志。

获取正在运行的Ignite Pod的列表：

bash

kubectl get pods --namespace=ignite

选择一个可用的Pod的名字：

NAME       READY     STATUS    RESTARTS   AGE
ignite-0   1/1       Running   0          7m
ignite-1   1/1       Running   0          4m

然后从中获取日志：

bash

kubectl logs ignite-0 --namespace=ignite

4.2.2.4.调整Ignite集群大小

属于标准的Kubernetes API，可以随时调整Ignite集群的大小。比如希望将集群从2个节点扩容到4个节点，可以使用下面的命令：

bash

kubectl scale sts ignite --replicas=4 --namespace=ignite

再次确认集群扩容成功：

bash

kubectl get pods --namespace=ignite

输出显示有4个Ignite Pod正在运行：

NAME       READY     STATUS    RESTARTS   AGE
ignite-0   1/1       Running   0          21m
ignite-1   1/1       Running   0          18m
ignite-2   1/1       Running   0          12m
ignite-3   1/1       Running   0          9m

4.2.2.5.Ignite集群激活

因为部署使用了Ignite的原生持久化，因此启动之后集群需要激活，怎么做呢，接入一个Pod：

bash

kubectl exec -it ignite-0 --namespace=ignite -- /bin/bash

转到下面的目录：

bash

cd /opt/ignite/apache-ignite-fabric/bin/

然后使用下面的命令可以激活集群：

bash

./control.sh --activate

4.2.3.RBAC授权

4.2.3.1.概述

基于角色的访问控制（RBAC）是一种企业内基于单个用户的角色来调节对计算机或网络资源访问的常规方法。

RBAC使用rbac.authorization.k8s.ioAPI组来驱动授权决策，允许管理员通过Kubernetes API动态地配置策略。

建议为Ignite部署配置RBAC，以对部署进行细粒度的控制，避免与安全有关的问题。

4.2.3.2.要求

假定已经部署好了一套Kubernetes集群环境。

4.2.3.3.创建命名空间

需要为Ignite部署创建一个唯一的命名空间，在本案例中命名空间名字为ignite：

ignite-namespace.yaml：

yaml

apiVersion: v1
kind: Namespace
metadata:
  name: ignite

执行下面的命令配置命名空间：

bash

kubectl create -f ignite-namespace.yaml

4.2.3.4.创建服务账户

通过下面的方式配置Ignite服务账户：

ignite-service-account.yaml：

yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: ignite
  namespace: ignite

执行下面的命令创建账户：

bash

kubectl create -f ignite-service-account.yaml

4.2.3.5.创建角色

通过下面的方式创建Ignite服务使用的角色，该服务用于节点的自动发现，并且用作远程应用的负载平衡器。

ignite-account-role.yaml：

yaml

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: Role
metadata:
  name: ignite
  namespace: ignite
rules:
- apiGroups:
  - ""
  resources: # Here are resources you can access
  - pods
  - endpoints
  verbs: # That is what you can do with them
  - get
  - list
  - watch

注意

如果不打算将Ignite服务用作外部应用的负载平衡器，那么建议赋予其更少的权限，具体见这里。

执行下面的命令创建角色：

bash

kubectl create -f ignite-account-role.yaml

下一步，使用下面的配置将该角色绑定到服务账户和命名空间上：

ignite-role-binding.yaml：

yaml

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: ignite
roleRef:
  kind: Role
  name: ignite
  apiGroup: rbac.authorization.k8s.io
subjects:
- kind: ServiceAccount
  name: ignite
  namespace: ignite

执行下面的命令执行绑定：

bash

kubectl create -f ignite-role-binding.yaml

最后，将命名空间切换到ignite，然后就可以看到所有所属的资源：

bash

kubectl config set-context $(kubectl config current-context) --namespace=ignite

4.2.4.Ignite服务

Ignite服务用于Ignite节点的自动发现，还有做为要接入集群的外部应用的负载平衡器。

本章节描述如何配置和部署Ignite服务。

4.2.4.1.Ignite服务部署

Ignite的KubernetesIPFinder需要用户配置和部署一个专用的Kubernetes服务，它会维护一个所有有效的Ignite Pod的IP地址列表。

每次启动一个新的Ignite Pod，IP探测器会通过Kubernetes API接入服务来获取已有的Ignite Pod地址列表。通过这些地址，新的节点就可以发现集群中的其它节点从而最终加入Ignite集群。

同时，也可以将该服务复用为预接入集群的外部应用的负载平衡器。

通过下面的方式可以配置服务，它考虑了所有的必要条件：

会话关联属性

只有在Kubernetes中部署了Ignite集群并且应用不在其中时，才需要下面使用的sessionAffinity。该属性确保Ignite瘦客户端、JDBC/ODBC驱动保留与特定的Ignite Pod的连接。如果集群和应用都由Kubernetes管理，那么该属性是冗余的，可以删除。

ignite-service.yaml：

yaml

apiVersion: v1
kind: Service
metadata:
  # The name must be equal to KubernetesConnectionConfiguration.serviceName
  name: ignite-service
  # The name must be equal to KubernetesConnectionConfiguration.namespace
  namespace: ignite
spec:
  type: LoadBalancer
  ports:
    - name: rest
      port: 8080
      targetPort: 8080
    - name: sql
      port: 10800
      targetPort: 10800
    - name: thinclients
      port: 10900
      targetPort: 10900
  sessionAffinity: ClientIP
  selector:
    # Must be equal to the label set for Ignite pods.
    app: ignite

然后使用如下的命令将其部署进Kubernetes（确认事先已经配置好了唯一的命名空间和RBAC）：

bash

kubectl create -f ignite-service.yaml

确认服务已经正在运行：

bash

 kubectl get svc ignite --namespace=ignite

4.2.5.Kubernetes IP探测器

4.2.5.1.概述

将Ignite节点以KubernetesPod的形式进行部署，对Ignite节点的发现机制有一定的要求。因为防火墙通常会阻止组播通信的原因，很可能无法直接使用基于组播的IP探测器。但是，只要Kubernetes动态地分配了地址，就可以列出所有节点的IP地址，然后使用静态IP探测器。

也可以考虑Amazon AWS IP探测器、Google Compute Engine IP探测器或者JClouds IP探测器，但是Kubernetes必须部署在这些云环境中。另外，也可以使用共享文件系统或者关系型数据库用于节点的自动发现，但是必须单独维护数据库或者共享文件系统。

本章节会描述有关针对使用Kubernetes技术容器化的Ignite节点，专门开发的IP探测器，该IP探测器会自动搜索所有在线的Ignite Pod的IP地址，它是通过与一个持有所有最新端点的Kubernetes服务进行通信实现的。

4.2.5.2.基于Kubernetes服务的发现

如果要开启Kubernetes环境的节点自动发现，需要在下面的配置中使用TcpDiscoveryKubernetesIpFinder：

XMLJava

xml

<bean class="org.apache.ignite.configuration.IgniteConfiguration">
	...
  <property name="discoverySpi">
    <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
      <property name="ipFinder">
        <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.kubernetes.TcpDiscoveryKubernetesIpFinder"/>
      </property>
    </bean>
  </property>
</bean>

java

// Configuring discovery SPI.
TcpDiscoverySpi spi = new TcpDiscoverySpi();

// Configuring IP finder.
TcpDiscoveryKubernetesIpFinder ipFinder = new TcpDiscoveryKubernetesIpFinder();

spi.setIpFinder(ipFinder);

IgniteConfiguration cfg = new IgniteConfiguration();

// Override default discovery SPI.
cfg.setDiscoverySpi(spi);

// Start Ignite node.
Ignition.start(cfg);

Maven构件

如果要使用TcpDiscoveryKubernetesIpFinder，需要在Maven中添加ignite-kubernetes依赖。

Ignite的KubernetesIPFinder需要用户配置和部署一个Kubernetes服务，它负责维护所有在线Ignite Pod（节点）的IP地址列表。

每当启动一个新的Ignite Pod，IP探测器会通过Kubernetes的API访问Kubernetes服务，获取已有的Ignite Pod的地址列表，通过这些地址，新的节点就可以与其它节点互相连接，然后最终加入集群。

该服务需要手工配置，然后需要优先于Ignite Pod先行启动，下面是代码样例：

Service Configuration：

yaml

apiVersion: v1
kind: Service
metadata:
  # Name of Ignite Service used by Kubernetes IP finder for IP addresses lookup.
  name: ignite
spec:
  clusterIP: None # custom value.
  ports:
    - port: 9042 # custom value.
  selector:
    # Must be equal to one of the labels set in Ignite pods'
    # deployement configuration.
    app: ignite

默认的服务名为ignite，如果修改了名字，一定要同时调用TcpDiscoveryKubernetesIpFinder.setServiceName(String)方法进行修改。

另外，建议通过某种方式对Ignite的Pod打标签，然后在服务的selector配置段中配置标签。比如，通过上面的配置启动的服务，会关注于标注为app: ignite的Pod。

从外部接入容器化的Ignite集群

TcpDiscoveryKubernetesIpFinder的设计是用于Kubernetes环境内部的，这意味着所有的Ignite节点、与集群交互的应用都需要通过Kubernetes容器化。

但是，如果希望从Kubernetes外部接入Ignite集群，那么：

需要在Ignite Pod的yaml文件中配置hostNetwork=true，这样就可以从外部与容器化的Ignite Pod建立TCP/IP连接；
在Kubernetes环境外部，使用同样的TcpDiscoveryKubernetesIpFinder。

4.2.5.3.配置参数

通常，TcpDiscoveryKubernetesIpFinder的设计是直接可用，但是通过下面的参数也可以进行细粒度的控制：

属性	描述	默认值
`setServiceName(String)`	配置Kubernetes服务的名字，该服务用于Ignite Pod的IP地址搜索，服务名必须与Kubernetes配置中的服务名一致。	`ignite`
`setNamespace(String)`	配置Kubernetes服务所属的命名空间。	`default`
`setMasterUrl(String)`	配置Kubernetes API服务器的主机名。	`https://kubernetes.default.svc.cluster.local:443`
`setAccountToken(String)`	配置服务令牌文件的路径。	`/var/run/secrets/kubernetes.io/serviceaccount/token`

5.在VMWare中安装Ignite

5.1.概述

Ignite可以部署于VMWare管理的虚拟和云环境，没有什么和VMWare有关的特性，不过建议将Ignite实例绑定到一个单一专用的主机，这样可以：

避免当Ignite实例与其它应用程序争用主机资源时，导致Ignite集群的性能出现峰值；
确保高可用，如果一台主机宕机并且有两个或者多个Ignite服务端节点绑定到上面，那么可能导致数据丢失。

下面的内容会说明和Ignite节点迁移有关的vMotion的使用。

5.2.使用vMotion进行节点迁移

vMotion可以将一个在线的实例从一台主机迁移到另一台，但是迁移之后Ignite依赖的一些基本要求要得到满足：

新主机有相同的内存状态；
新主机有相同的磁盘状态（或新主机使用相同的磁盘）；
IP地址、可用的端口以及其它的网络参数没有变化；
所有的网络资源可用，TCP连接没有中断。

如果vMotion按照上述规则设置并工作，则Ignite节点将正常工作。

不过vMotion迁移将影响Ignite实例的性能。在传输过程中，许多资源（主要是CPU和网络）将服务于vMotion的需要。

为了避免集群一段时间内的性能下降甚至无响应，建议如下：

在Ignite集群的低活跃和负载期间执行迁移。这确保了更快的传输，同时对集群性能影响最小；
如果必须迁移多个节点，则需要一个个按顺序地执行节点的迁移；
将IgniteConfiguration.failureDetectionTimeout参数设置为高于Ignite实例的可能停机时间的值。这是因为当剩下一小块状态要传输时，vMotion将停止Ignite实例的CPU。假定传输该数据块需要X时间，那么IgniteConfiguration.failureDetectionTimeout必须大于X；否则节点将从集群中删除；
使用高吞吐量网络。最好vMotion迁移器和Ignite集群使用不同的网络来避免网络饱和；
优先选择内存较少的节点，较小内存的Ignite实例确保更快的vMotion迁移，更快的迁移确保Ignite集群更稳定的操作；
如果业务允许，甚至可以考虑在Ignite实例停机时进行迁移。假设集群中的其它节点上有数据的备份副本，则可以先将该节点关闭，然后在vMotion迁移结束后恢复该节点，这样和在线迁移相比，可能总体性能更好（集群的性能和vMotion传输时间）。

18624049226

安装 ​

1.使用ZIP压缩包安装 ​

1.1.环境要求 ​

1.2.使用ZIP压缩包安装 ​

2.使用Docker安装 ​

2.1.注意事项 ​

2.2.下载Ignite的Docker镜像 ​

2.3.运行内存集群 ​

2.4.运行持久化集群 ​

2.4.1.使用持久化卷 ​

2.4.2.使用本地目录 ​

2.5.提供配置文件 ​

2.6.部署自己的库文件 ​

2.7.启用模块 ​

2.8.环境变量 ​

3.使用DEB/RPM包安装 ​

3.1.概述 ​

3.2.仓库的配置 ​

3.3.Ignite的安装 ​

3.4.将Ignite作为服务 ​

3.5.将Ignite作为独立进程 ​

3.6.在Windows10 WSL中运行Ignite ​

4.Kubernetes ​

4.1.Kubernetes部署 ​

4.2.常规配置 ​

4.2.1.无状态部署 ​

4.2.1.1.要求 ​

4.2.1.2.Kubernetes IP探测器 ​

4.2.1.3.Ignite Pod部署 ​

4.2.1.4.调整Ignite集群大小 ​

4.2.1.5.在OpenShift环境中部署 ​

4.2.2.有状态部署 ​

4.2.2.1.要求 ​

4.2.2.2.Kubernetes IP探测器 ​

4.2.2.3.有状态集部署 ​

4.2.2.4.调整Ignite集群大小 ​

4.2.2.5.Ignite集群激活 ​

4.2.3.RBAC授权 ​

4.2.3.1.概述 ​

4.2.3.2.要求 ​

4.2.3.3.创建命名空间 ​

4.2.3.4.创建服务账户 ​

4.2.3.5.创建角色 ​

4.2.4.Ignite服务 ​

4.2.4.1.Ignite服务部署 ​

4.2.5.Kubernetes IP探测器 ​

4.2.5.1.概述 ​

4.2.5.2.基于Kubernetes服务的发现 ​

4.2.5.3.配置参数 ​

5.在VMWare中安装Ignite ​

5.1.概述 ​

5.2.使用vMotion进行节点迁移 ​

安装

1.使用ZIP压缩包安装

1.1.环境要求

1.2.使用ZIP压缩包安装

2.使用Docker安装

2.1.注意事项

2.2.下载Ignite的Docker镜像

2.3.运行内存集群

2.4.运行持久化集群

2.4.1.使用持久化卷

2.4.2.使用本地目录

2.5.提供配置文件

2.6.部署自己的库文件

2.7.启用模块

2.8.环境变量

3.使用DEB/RPM包安装

3.1.概述

3.2.仓库的配置

3.3.Ignite的安装

3.4.将Ignite作为服务

3.5.将Ignite作为独立进程

3.6.在Windows10 WSL中运行Ignite

4.Kubernetes

4.1.Kubernetes部署

4.2.常规配置

4.2.1.无状态部署

4.2.1.1.要求

4.2.1.2.Kubernetes IP探测器

4.2.1.3.Ignite Pod部署

4.2.1.4.调整Ignite集群大小

4.2.1.5.在OpenShift环境中部署

4.2.2.有状态部署

4.2.2.1.要求

4.2.2.2.Kubernetes IP探测器

4.2.2.3.有状态集部署

4.2.2.4.调整Ignite集群大小

4.2.2.5.Ignite集群激活

4.2.3.RBAC授权

4.2.3.1.概述

4.2.3.2.要求

4.2.3.3.创建命名空间

4.2.3.4.创建服务账户

4.2.3.5.创建角色

4.2.4.Ignite服务

4.2.4.1.Ignite服务部署

4.2.5.Kubernetes IP探测器

4.2.5.1.概述

4.2.5.2.基于Kubernetes服务的发现

4.2.5.3.配置参数

5.在VMWare中安装Ignite

5.1.概述

5.2.使用vMotion进行节点迁移