Como configurar um MongoDB NoSQL Cluster Utilizando o Oracle Solaris Zones ~ MongoDB Wise

Como configurar um cluster MongoDB NoSQL em um sistema baseado em x86 com Oracle Solaris Zones eo Service Management Facility Oracle Solaris 11 e uma ferramenta de análise DTrace.

Este artigo começa com uma breve visão geral do MongoDB e segue com um exemplo de criação de um cluster MongoDB três nós em um sistema baseado em x86. Como pré-requisito, você deve ter uma compreensão básica do Oracle Solaris Zones e administração de redes.

Sobre o MongoDB e Oracle Solaris Zones

MongoDB é um banco de dados orientado a documentos open source NoSQL que armazena dados estruturados como JavaScript Object Notation (JSON)-como documentos com esquemas dinâmicos. Isso permite um rápido desenvolvimento desde os esquemas de banco de dados podem ser modificados rapidamente aplicações evoluir sem a necessidade de desligar o banco de dados. Além disso, MongoDB suporta replicação master-slave, utilizando um conjunto de replicação, e também fornece escalabilidade horizontal com o recurso sharding, que permite distribuir os dados (com base em uma chave caco) em vários servidores MongoDB.

A seguir, são os benefícios do uso do Oracle Solaris para um cluster MongoDB :

Você pode adicionar novos hosts do MongoDB para o cluster em minutos em vez de horas, usando o recurso de clonagem zona. Utilizando o Oracle Solaris Zones, você pode facilmente escalar seu cluster MongoDB.

No caso de haver um erro do usuário ou erro de software, o Service Management Facility garante a alta disponibilidade de cada membro do cluster e garante que failover replicação MongoDB irá ocorrer apenas como último recurso.

Você pode descobrir problemas de desempenho em minutos em vez de dias usando o DTrace, o que proporciona uma maior observabilidade do sistema operacional. DTrace fornece uma visão holística do desempenho do sistema operacional e permite a análise de desempenho de profundidade através da cooperação com o built-in de ferramentas MongoDB.

ZFS compressão built-in fornece disco otimizado e utilização de I/O para um melhor desempenho.

No exemplo apresentado neste artigo, todos os blocos de construção de cluster MongoDB serão instalados usando as zonas do Oracle Solaris Service Management Facility, ZFS e tecnologias de virtualização de rede. A Figura 1 mostra a arquitetura:

[caption id="attachment_42" align="aligncenter" width="548"]

Figura 1. Arquitetura[/caption]

Baixe e instale MongoDB

Para este artigo, eu usei Oracle Solaris 11.1, que você pode baixar aqui.

1. Para se ter uma distribuição MongoDB, faça o download de uma versão estável recente do site de download do MongoDB. Para este artigo, eu usei a 64-bit 2.4.1 liberação MongoDB Oracle Solaris.

Nota: Apenas as versões para o Oracle Solaris em sistemas baseados em x86 estão disponíveis. Não há versões estã disponíveis para os sistemas baseados em SPARC ..

2. Na região global, criar o diretório /usr/local se ele não existe. A configuração do cluster vai compartilhar a estrutura de diretórios MongoDB através das zonas como um sistema de arquivos somente leitura.

root@global_zone:~# mkdir -p /usr/local

3. Copie o arquivo tar MongoDB em /usr/local:

root@global_zone:~# cp /tmp/mongodb-sunos5-x86_64-2.4.1.tgz /usr/local

4. Descompacte o arquivo tar:

root@global_zone:~# cd /usr/local
root@global_zone:~# tar -xvfz /usr/local/mongodb-sunos5-x86_64-2.4.1.tgz

5. Renomeie a localização dos binários MongoDB:

root@global_zone:~# ln -s /usr/local/mongodb-sunos5-x86_64-2.4.1 /usr/local/mongodb

6. Crie o diretório de configuração do MongoDB:

root@global_zone:~# mkdir /usr/local/mongodb/etc

7. Crie o diretório de bibliotecas extras MongoDB:

root@global_zone:~# mkdir /usr/local/mongodb/mongo-extra-64

8. MongoDB requer uma versão atualizada do libstdc. Baixe o pacote libstdc aqui

9. Descompacte o pacote libstdc:

root@global_zone:~# gzip -d /tmp/libstdc++6-4.7.2,REV=2013.03.28-SunOS5.10-i386-CSW.pkg.gz

10. Converta o pacote para um formato de sistema de arquivo usando o comando pkgtrans:

root@global_zone:~# cd /tmp root@global_zone:~# pkgtrans /tmp/libstdc++6-4.7.2\,REV\=2013.03.28-SunOS5.10-i386-CSW.pkg /tmp

11. A saída a seguir irá aparecer. Pressione Enter no prompt:

The following packages are available:
  1  CSWlibstdc++6     libstdc++6 - The GNU Compiler Collection, libstdc++.so.6 (i386) 4.7.2,REV=2013.03.28

  Select package(s) you wish to process (or 'all' to process
all packages). (default: all) [?,??,q]:

12. Copie a biblioteca libstdc para /usr/local/mongodb/mongo-extra-64 /:

root@global_zone:~# cp /tmp/CSWlibstdc++6/root/opt/csw/lib/amd64/libstdc++.so.6.0.17 \
/usr/local/mongodb/mongo-extra-64/

13 .Criar o grupo para o MongoDB:

root@global_zone:~# groupadd mongodb

14. Adicione o usuário MongoDB e defina a senha do usuário:

root@global_zone:~# useradd -g mongodb mongodb
root@global_zone:~# passwd mongodb

15. Criar o diretório home do usuário MongoDB:

root@global_zone:~# mkdir -p /export/home/mongodb
root@global_zone:~# chown -R mongodb:mongodb /export/home/mongodb

16. Editar as pastas de configuração de MongoDB, como mostrados na Tabela 1:

[caption id="attachment_50" align="aligncenter" width="461"]

Tabela 1. Arquivos de configuração MongoDB[/caption]

Observação: Para saber mais sobre como MongoDB é controlado por esses arquivos de configuração, consulte o manual do MongoDB.

a. Altere os diretórios:

root@global_zone:~# cd /usr/local/mongodb/etc

b.Em seguida, edite o arquivo mongodb.conf para definir os valores das propriedades descritas na Tabela 2:

root@global_zone:~# vi mongodb.conf
fork = true
quiet = true
logpath = /var/log/mongodb/mongod.log
logappend = true
replSet = rs0
rest = true

[caption id="attachment_51" align="aligncenter" width="620"]

Tabela 2. Propriedades de configuração MongoDB[/caption]

c.Edite o arquivo de script de inicialização do MongoDB para que ele se parece com o seguinte:

root@global_zone:~# vi  /usr/local/mongodb/bin/mongodb-start
#!/usr/bin/bash
export LD_PRELOAD_64=/usr/local/mongodb/mongo-extra-64/libstdc++.so.6.0.17:/lib/amd64/libumem.so
export LC_ALL=C
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/etc/mongodb.conf

17. Altere a propriedade de diretório:

root@global_zone:~# chown -R mongodb:mongodb /usr/local/mongodb-sunos5-x86_64-2.4.1
root@global_zone:~# chmod -R 755 /usr/local/mongodb-sunos5-x86_64-2.4.1

Criar as interfaces de rede virtuais

Criar uma série de interfaces de rede virtuais (VNICs) para as zonas MongoDB:

root@global_zone:~# dladm create-vnic -l net0 mongodb_node1
root@global_zone:~# dladm create-vnic -l net0 mongodb_node2
root@global_zone:~# dladm create-vnic -l net0 mongodb_node3

Configure o Network Time Protocol

Devemos assegurar que o relógio do sistema em zonas MongoDB é sincronizado usando o Network Time Protocol (NTP).

Nota: É melhor para selecionar um servidor NTP que pode ser uma fonte de sincronização de tempo dedicado para que outros serviços não são afetados negativamente, se a máquina for desligada para manutenção planejada.

No exemplo a seguir, a região global é configurado como um servidor NTP.

1. Configure an NTP server:

root@global_zone:~# cd /etc/inet
root@global_zone:~# cp ntp.server ntp.conf
root@global_zone:~# touch /var/ntp/ntp.drift

2. Edite o arquivo de configuração do servidor NTP, como mostrado na Listagem 1:

root@global_zone:~# vi /etc/inet/ntp.conf

server 127.127.1.0 prefer
broadcast 224.0.1.1 ttl 4
enable auth monitor
driftfile /var/ntp/ntp.drift
statsdir /var/ntp/ntpstats/
filegen peerstats file peerstats type day enable
filegen loopstats file loopstats type day enable
filegen clockstats file clockstats type day enable
keys /etc/inet/ntp.keys
trustedkey 0
requestkey 0
controlkey 0

Listing 1. NTP Server Configuration File

3. Habilitar o serviço do servidor NTP:

root@global_zone:~# svcadm enable ntp

4. Verifique se o servidor NTP é on-line usando o seguinte comando:

root@global_zone:~# svcs -a | grep ntp
online         16:04:15 svc:/network/ntp:default

Edite a configuração de consumo de memória do ZFS

Ambos MongoDB e Oracle Solaris ZFS são processos que exigem muita memória. A fim de evitar a falta de memória para a instância MongoDB, você precisa reduzir a memória consumida pelo cache ZFS ARC ajustando o parâmetro zfs_arc_max para um valor baixo.

1.Defina o parâmetro de valor baixo, por exemplo 2GB, como mostrado no exemplo a seguir:

root@global_zone:~# echo "set zfs:zfs_arc_max=2147483648" >> /etc/system

2.Use o seguinte comando para monitorar a quantidade de memória do ZFS ARC está usando:

root@global_zone:~# kstat -m zfs -s c_max
module: zfs                             instance: 0
name:   arcstats                        class:    misc
        c_max                           2147483648

Você pode ver a saída que o valor da propriedade zfs_arc_max é agora 2 GB. (c_max é o valor para zfs_arc_max na saída do comando kstat.)

3.Reinicie o sistema, a fim de reforçar o valor da propriedade em /etc/system.

root@global_zone:~# reboot

Criar as Zonas MongoDB

A Tabela 3 apresenta um resumo da configuração da zona MongoDB vamos criar:

[caption id="attachment_53" align="aligncenter" width="598"]

Tabela 3. Resumo Zona[/caption]

1. Se você não tiver um sistema de arquivos para as zonas MongoDB, execute o seguinte comando:

root@global_zone:~# zfs create -o compression=on -o mountpoint=/zones rpool/zones

2.Criar a zona mongodb-node1, como mostrado na Listagem 2:

root@global_zone:~# zonecfg -z mongodb-node1
Use 'create' to begin configuring a new zone.
zonecfg:mongodb-node1> create
create: Using system default template 'SYSdefault'
zonecfg:mongodb-node1> set limitpriv="default,sys_time"
zonecfg:mongodb-node1> set autoboot=true
zonecfg:mongodb-node1> set zonepath=/zones/mongodb-node1
zonecfg:mongodb-node1> add fs
zonecfg:mongodb-node1:fs> set dir=/usr/local
zonecfg:mongodb-node1:fs> set special=/usr/local
zonecfg:mongodb-node1:fs> set type=lofs
zonecfg:mongodb-node1:fs> set options=[ro,nodevices]
zonecfg:mongodb-node1:fs> end
zonecfg:mongodb-node1> add net
zonecfg:mongodb-node1:net> set physical=mongodb_node1
zonecfg:mongodb-node1:net> end
zonecfg:mongodb-node1> add capped-memory
zonecfg:mongodb-node1:capped-memory> set physical=14g
zonecfg:mongodb-node1:capped-memory> end
zonecfg:mongodb-node1> verify
zonecfg:mongodb-node1> exit

Listing 2. Creating the mongodb-node1 Zone

3. Criar a segunda zona MongoDB, como mostrado na Listagem 3:

root@global_zone:~# zonecfg -z mongodb-node2
Use 'create' to begin configuring a new zone.
zonecfg:mongodb-node2> create
create: Using system default template 'SYSdefault'
zonecfg:mongodb-node2> set limitpriv="default,sys_time"
zonecfg:mongodb-node2> set autoboot=true
zonecfg:mongodb-node2> set zonepath=/zones/mongodb-node2
zonecfg:mongodb-node2> add fs
zonecfg:mongodb-node2:fs> set dir=/usr/local
zonecfg:mongodb-node2:fs> set special=/usr/local
zonecfg:mongodb-node2:fs> set type=lofs
zonecfg:mongodb-node2:fs> set options=[ro,nodevices]
zonecfg:mongodb-node2:fs> end
zonecfg:mongodb-node2> add net
zonecfg:mongodb-node2:net> set physical=mongodb_node2
zonecfg:mongodb-node2:net> end
zonecfg:mongodb-node2> add capped-memory
zonecfg:mongodb-node2:capped-memory> set physical=14g
zonecfg:mongodb-node2:capped-memory> end
zonecfg:mongodb-node2> verify
zonecfg:mongodb-node2> exit

Listing 3. Creating the mongodb-node2 Zone

4. Criar a terceira zona MongoDB, como mostrado na Listagem 4:

root@global_zone:~# zonecfg -z mongodb-node3
Use 'create' to begin configuring a new zone.
zonecfg:mongodb-node3> create
create: Using system default template 'SYSdefault'
zonecfg:mongodb-node3> set limitpriv="default,sys_time"
zonecfg:mongodb-node3> set autoboot=true
zonecfg:mongodb-node3> set zonepath=/zones/mongodb-node3
zonecfg:mongodb-node3> add fs
zonecfg:mongodb-node3:fs> set dir=/usr/local
zonecfg:mongodb-node3:fs> set special=/usr/local
zonecfg:mongodb-node3:fs> set type=lofs
zonecfg:mongodb-node3:fs> set options=[ro,nodevices]
zonecfg:mongodb-node3:fs> end
zonecfg:mongodb-node3> add net
zonecfg:mongodb-node3:net> set physical=mongodb_node3
zonecfg:mongodb-node3:net> end
zonecfg:mongodb-node3> add capped-memory
zonecfg:mongodb-node3:capped-memory> set physical=14g
zonecfg:mongodb-node3:capped-memory> end
zonecfg:mongodb-node3> verify
zonecfg:mongodb-node3> exit

Listing 4. Creating the mongodb-node3 Zone

5. Agora, instalar a região mongodb-zone1; mais tarde vamos clonar esta zona, a fim de acelerar a criação de zona para as outras zonas.

root@global_zone:~# zoneadm -z mongodb-node1 install

6.Inicialize a região mongodb-node1 e verificar o estado das zonas que criamos, como mostrado na Listagem 5:

root@global_zone:~# zoneadm -z mongodb-node1 boot
root@global_zone:~# zoneadm list -cv
ID NAME             STATUS     PATH                   BRAND    IP
0  global           running    /                      solaris  shared
1  mongodb-node1    running    /zones/mongodb-node1   solaris  excl
-  mongodb-node2    configured /zones/mongodb-node2   solaris  excl
-  mongodb-node3    configured /zones/mongodb-node3   solaris  excl
root@global_zone:~# zlogin -C mongodb-node1

Listing 5. Booting the mongodb-node1 Zone

7. Forneça as informações de host da região, utilizando a seguinte configuração para a zona mongodb-node1

Para o nome do host, use mongodb-node1.

Verifique se a interface de rede para mongodb_node1 tem um endereço IP de 192.168.1.1/24.

Verifique se o serviço de nome é baseado em sua configuração de rede. Neste artigo, vamos usar o /etc/hosts para resolução de nomes. Opcionalmente, você pode configurar o DNS para resolução de nomes de host ..

8. Depois de terminar a configuração da zona, você irá obter o prompt de login. Entrar para a zona como root usando a senha de root.

9. MongoDB requer bibliotecas para o seu ambiente, para instalar o compilador gcc versão 4.5 usando o seguinte comando:

root@mongodb-node1:~# pkg install gcc-45

10.Crie o grupo MongoDB:

root@mongodb-node1:~# groupadd mongodb

11.Adicione o usuário MongoDB e definir a senha do usuário:

root@mongodb-node1:~# useradd -g mongodb mongodb
root@mongodb-node1:~# passwd mongodb

12.Criar o diretório home do usuário MongoDB:

root@mongodb-node1:~# mkdir -p /export/home/mongodb

13.Edite o script de inicialização usuários do bash shell MongoDB, como mostrado na Listagem 6:

root@mongodb-node1:~# vi /export/home/mongodb/.profile

PATH=/usr/local/mongodb/bin:$PATH
export LD_PRELOAD_64=/lib/secure/64/libstdc++.so.6.0.1
export LC_ALL=C
ulimit -n 20000

case ${SHELL} in
*bash)
typeset +x PS1="\u@\h:\w\\$ "
;;
esac

Listing 6. Editing the Initialization Script

14.Altere a propriedade MongoDB diretório home:

root@mongodb-node1:~# chown -R mongodb:mongodb /export/home/mongodb

15.Crie um diretório para os arquivos de dados MongoDB:

root@mongodb-node1:~# mkdir -p /data/db
root@mongodb-node1:~# chown -R mongodb:mongodb /data/db

16.Crie um diretório para os arquivos de log MongoDB:

root@mongodb-node1:~# mkdir /var/log/mongodb
root@mongodb-node1:~# chown -R mongodb:mongodb /var/log/mongodb

17.Crie um link simbólico para a biblioteca libstdc a fim de adicioná-lo como uma biblioteca de segurança:

root@mongodb-node1:~# ln -s /usr/local/mongodb/mongo-extra-64/libstdc++.so.6.0.17 /lib/secure/64

18.Configurar um cliente NTP, conforme mostrado no exemplo a seguir:

a. Instale o pacote NTP:

root@mongodb-node1:~# pkg install ntp

b.Crie os arquivos de configuração do cliente NTP:

root@mongodb-node1:~# cd /etc/inet
root@mongodb-node1:~# cp ntp.client ntp.conf
root@mongodb-node1:~# touch /var/ntp/ntp.drift

19.Edite o arquivo de configuração do cliente NTP da seguinte forma:

root@mongodb-node1:~# vi /etc/inet/ntp.conf
server <ntp-server> prefer
driftfile /var/ntp/ntp.drift
statsdir /var/ntp/ntpstats/
filegen peerstats file peerstats type day enable
filegen loopstats file loopstats type day enable

Nota: Substitua o endereço IP ntp-servidor com o endereço IP ou nome do host do servidor de hora local ou com o endereço IP ou nome do host de um servidor recomendado pelo http://support.ntp.org/bin/view/Servers/NTPPoolServers.

20. Ative o serviço de cliente NTP:

root@mongodb-node1:~# svcadm enable ntp

21. Verifique o status do cliente NTP:

root@mongodb-node1:~# svcs ntp
STATE          STIME    FMRI
online         12:44:01 svc:/network/ntp:default

22.Verifique se o cliente NTP pode sincronizar seu relógio com o servidor NTP:

root@mongodb-node1:~# ntpq -p

23.Adicionar nomes de host aos membros do cluster MongoDB "e endereços IP para /etc/hosts:

root@mongodb-node1:~# cat /etc/hosts

::1        localhost
127.0.0.1  localhost loghost
192.168.1.1 mongodb-node1
192.168.1.2 mongodb-node2
192.168.1.3 mongodb-node3

Nota: Se você estiver usando NTP, você precisa adicionar o nome do servidor NTP e endereços IP para o / etc / hosts.

Configure o Service Management Facility

O Facility Management Service é um recurso do Oracle Solaris para gerenciamento de serviços de sistema e de aplicativos, substituindo a inicialização de scripts de inicialização legado. Service Management Facility melhora a disponibilidade de um sistema, garantindo que os serviços essenciais do sistema e de aplicativos executados continuamente, mesmo em caso de falhas de hardware ou software. Além disso, a capacidade de auto-restart Service Management Facility pode reiniciar os serviços do sistema operacional em caso de erro, sem qualquer intervenção humana.

1.Use a ferramenta svcbundle para criar um Mecanismo de Gestão de Serviços de manifesto que será iniciado automaticamente após a reinicialização MongoDB e reiniciar o serviço se houver um erro.

root@mongodb-node1:~# svcbundle -s service-name=application/mongodb \
-s start-method="/usr/local/mongodb/bin/mongodb-start" \
-s model=daemon -o mongodb.xml

2.Edite o manifesto mondodb.xml para habilitar a inicialização do serviço usando o grupo MongoDB e usuário. Para fazer isso, após a linha que contém </ dependency>, adicione as seguintes linhas:

<method_context>
   <method_credential group="mongodb" user="mongodb"/>
</method_context>

Listing 7 shows the MongoDB Service Management Facility manifest after the modification:

root@mongodb-node1:~# vi mongodb.xml
<?xml version="1.0" ?>
<!DOCTYPE service_bundle
  SYSTEM '/usr/share/lib/xml/dtd/service_bundle.dtd.1'>
<!--
    Manifest created by svcbundle (2013-Apr-10 11:04:28+0300)
-->
<service_bundle type="manifest" name="application/mongodb">
    <service version="1" type="service" name="application/mongodb">
        <!--
            The following dependency keeps us from starting until the
            multi-user milestone is reached.
        -->
        <dependency restart_on="none" type="service"
            name="multi_user_dependency" grouping="require_all">
            <service_fmri value="svc:/milestone/multi-user"/>
        </dependency>
        <method_context>
               <method_credential group="mongodb" user="mongodb"/>
        </method_context>
        <exec_method timeout_seconds="60" type="method" name="start"
            exec="/usr/local/mongodb/bin/mongodb-start"/>
        <!--
            The exec attribute below can be changed to a command that SMF
            should execute to stop the service.  See smf_method(5) for more
            details.
        -->
        <exec_method timeout_seconds="60" type="method" name="stop"
            exec=":kill"/>
        <!--
            The exec attribute below can be changed to a command that SMF
            should execute when the service is refreshed.  Services are
            typically refreshed when their properties are changed in the
            SMF repository.  See smf_method(5) for more details.  It is
            common to retain the value of :true which means that SMF will
            take no action when the service is refreshed.  Alternatively,
            you may wish to provide a method to reread the SMF repository
            and act on any configuration changes.
        -->
        <exec_method timeout_seconds="60" type="method" name="refresh"
            exec=":true"/>
        <!--
            We do not need a duration property group, because contract is
            the default.  Search for duration in svc.startd(1M).
        -->
        <instance enabled="true" name="default"/>
        <template>
            <common_name>
                <loctext xml:lang="C">
                    <!--
                        Replace this comment with a short name for the
                        service.
                    -->
                </loctext>
            </common_name>
            <description>
                <loctext xml:lang="C">
                    <!--
                        Replace this comment with a brief description of
                        the service
                    -->
                </loctext>
            </description>
        </template>
    </service>
</service_bundle>

Listing 7. MongoDB Service Management Facility Manifest

3.Validar o manifesto usando o seguinte comando:

root@global_zone:~# svccfg validate mongodb.xml

4. Inicie o serviço MongoDB:

root@global_zone:~# svccfg import mongodb.xml

5.Verifique se o serviço MongoDB foi iniciado:

root@mongodb-node1:~# svcs mongodb
STATE          STIME    FMRI
online         14:51:52 svc:/application/mongodb:default

6.Você pode monitorar as mensagens de inicialização MongoDB utilizando os seguintes comandos:

root@mongodb-node1:~# su - mongodb
mongodb@mongodb-node1:~ tail -f /var/log/mongodb/mongod.log

7.Verifique se o MongoDB é executado através da execução do comando mongotop, que mostra a quantidade de tempo que uma instância MongoDB gasta lendo e escrevendo dados:

mongodb@mongodb-node1:~ /usr/local/mongodb/bin/mongotop
        connected to: 127.0.0.1

                            ns       total        read       write   2013-04-08T16:44:12
             mydb.system.users         0ms         0ms         0ms
            local.system.users         0ms         0ms         0ms
          local.system.replset         0ms         0ms         0ms
          local.system.indexes         0ms         0ms         0ms
             local.startup_log         0ms         0ms         0ms
        local.replset.minvalid         0ms         0ms         0ms
                local.oplog.rs         0ms         0ms         0ms
                      local.me         0ms         0ms         0ms

Listing 8. Verifying That MongoDB Is Running

8.A partir da região global, execute os seguintes comandos para criar a zona mongodb-node2 como um clone do mongodb-node1:

root@global_zone:~# zoneadm -z mongodb-node1 shutdown 
root@global_zone:~# zoneadm -z mongodb-node2 clone mongodb-node1

9.Inicialize a região mongodb-node2:

root@global_zone:~# zoneadm -z mongodb-node2 boot
root@global_zone:~# zlogin -C mongodb-node2

10.Como se viu anteriormente, a ferramenta de configuração do sistema é iniciado. Então faça a configuração final para a zona mongodb-node2:

Para o nome do host, use mongodb-node2.

Para a interface de rede, use mongodb_node2.

Use um endereço IP 192.168.1.2/24.

Verifique se o serviço de nomes é definido como "none".

11.A partir da região global, execute os passos semelhantes para mongodb-node3:

root@global_zone:~# zoneadm -z mongodb-node3 clone mongodb-node1
root@global_zone:~# zoneadm -z mongodb-node3 boot
root@global_zone:~# zlogin -C mongodb-node3

12.Faça a configuração final para a zona mongodb-node3:

Para o nome do host, use mongodb-node3.

Para a interface de rede, use mongodb_node3.

Use um endereço IP 192.168.1.3/24.

Verifique se o serviço de nomes é definido como nenhum.

13.Inicialize a região mongodb-no1:

root@global_zone:~# zoneadm -z mongodb-node1 boot

14.Verifique se todas as zonas estão em funcionamento:

root@global_zone:~# zoneadm list -cv
 ID NAME          STATUS     PATH                     BRAND    IP
  0 global        running    /                        solaris shared
  1 mongodb-node1 running    /zones/mongodb-node1     solaris  excl
  2 mongodb-node2 running    /zones/mongodb-node2     solaris  excl
  3 mongodb-node3 running    /zones/mongodb-node3     solaris  excl

Verifique a resolução de nomes

Verifique se todas as zonas MongoDB tem as seguintes entradas de host em /etc/hosts:

# cat /etc/hosts

::1         localhost
127.0.0.1   localhost loghost
192.168.1.1 mongodb-node1             
192.168.1.2 mongodb-node2
192.168.1.3 mongodb-node3

Nota: Se você estiver usando um servidor NTP, você também deve adicionar o nome do host eo endereço IP para o /etc/hosts.

Configurar MongoDB Replication

A replicação ocorre através de grupos de servidores conhecidos como conjuntos de réplicas. A maioria dos conjuntos de réplicas consisti de duas ou mais instâncias mongod com no máximo, um deles designado como membro primário e o resto como membros secundários. Clientes direcionam todas as gravações para o membro primário, enquanto os membros secundários replicam a partir do primário de forma assíncrona. Replicação de banco de dados com MongoDB oferece redundância e ajuda a garantir alta disponibilidade. Além disso, isso simplifica apoios e pode aumentar a capacidade de leitura. A maioria das implantações de produção usam replicação.

Neste exemplo, mongodb-node1 será o membro primário e mongodb-node2 e mongodb-node3 serão membros secundários sobre o conjunto RS0 réplica, como mostra a Tabela 4.

Tabela 4. Configuração de replicação

Host Name	Function	Replica Set

mongodb-node1 primary rs0

mongodb-node2 secondary rs0

mongodb-node3 secondary rs0

1. Em cada zona, verificar se a instância MongoDB está instalado e funcionando usando o seguinte comando:

root@mongodb-node1:~# svcs mongodb
STATE          STIME    FMRI
online         14:51:52 svc:/application/mongodb:default

2.No primeiro nó (mongodb-node1), conecte no shell do MongoDB usando o seguinte comando:

root@mongodb-node1:~# su - mongodb
mongodb@mongodb-node1:~ /usr/local/mongodb/bin/mongo

3.Digite a seguinte sequência de comandos, a fim de adicionar mongodb-node1 para o conjunto de réplicas RS0.

>  rsconf = { _id: "rs0", members: [  {  _id: 0,  host: "mongodb-node1:27017" } ]  }

Você deve obter o seguinte output:

{
        "_id" : "rs0",
        "members" : [
                {
                        "_id" : 0,
                        "host" : "mongodb-node1:27017"
                }
        ]
}

4.Use o seguinte comando para iniciar um conjunto de réplicas que consiste no membro atual e usando a configuração padrão:

> rs.initiate( rsconf )

Você deve obter o seguinte output:

{
        "info" : "Config now saved locally.  Should come online in about a minute.",
        "ok" : 1
}

5.Mostrar a configuração atual conjunto de réplicas:

> rs.conf()

Você deve obter o seguinte resultado, que mostra somente um nó (mongodb-node1) no conjunto de réplicas:

{
        "_id" : "rs0",
        "version" : 1,
        "members" : [
                {
                        "_id" : 0,
                        "host" : "mongodb-node1:27017"
                }
        ]
}

6.Em seguida, adicione a segunda e terceira instâncias mongod (mongodb-node2, mongodb-node3) ao conjunto de réplicas RS0 usando o (método) rs.add:

rs0:PRIMARY>  rs.add("mongodb-node2")
  { "ok" : 1 }

rs0:PRIMARY> rs.add("mongodb-node3")
   { "ok" : 1 }

7.Execute o comando a seguir para garantir que a replicação está configurada corretamente e para verificar as conexões entre os atuais membros do conjunto de réplicas.

rs0:PRIMARY> rs.status()

A saída mostrada na Listagem 9 deve aparecer:

{
        "set" : "rs0",
        "date" : ISODate("2013-04-10T08:23:00Z"),
        "myState" : 1,
        "members" : [
                {
                        "_id" : 0,
                        "name" : "mongodb-node1:27017",
                        "health" : 1,
                        "state" : 1,
                        "stateStr" : "PRIMARY",
                        "uptime" : 536,
                        "optime" : {
                                "t" : 1365582138,
                                "i" : 1
                        },
                        "optimeDate" : ISODate("2013-04-10T08:22:18Z"),
                        "self" : true
                },
                {
                        "_id" : 1,
                        "name" : "mongodb-node2:27017",
                        "health" : 1,
                        "state" : 2,
                        "stateStr" : "SECONDARY",
                        "uptime" : 58,
                        "optime" : {
                                "t" : 1365582138,
                                "i" : 1
                        },
                        "optimeDate" : ISODate("2013-04-10T08:22:18Z"),
                        "lastHeartbeat" : ISODate("2013-04-10T08:22:58Z"),
                        "lastHeartbeatRecv" : ISODate("2013-04-10T08:22:58Z"),
                        "pingMs" : 0
                },
                {
                        "_id" : 2,
                        "name" : "mongodb-node3:27017",
                        "health" : 1,
                        "state" : 2,
                        "stateStr" : "SECONDARY",
                        "uptime" : 42,
                        "optime" : {
                                "t" : 1365582138,
                                "i" : 1
                        },
                        "optimeDate" : ISODate("2013-04-10T08:22:18Z"),
                        "lastHeartbeat" : ISODate("2013-04-10T08:22:58Z"),
                        "lastHeartbeatRecv" : ISODate("2013-04-10T08:22:59Z"),
                        "pingMs" : 0
                }
        ],
        "ok" : 1
}

Listing 9. Checking the Replication Configuration

Você pode ver a saída que mongodb-node1 é o primário e mongodb-node2 e mongodb-node3 são os membros de cluster secundários.

Executar operações básicas de banco de dados

O banco de dados MongoDB contém um conjunto de coleções. A coleção contém um conjunto de documentos. Um documento é um conjunto de pares de valores-chave.

Documentos têm esquema dinâmico, o que significa que os documentos na mesma coleção não precisa ter o mesmo conjunto de campos ou estrutura, e campos comuns em documentos de uma coleção pode conter diferentes tipos de dados.

Para exibir a lista de bancos de dados, use o seguinte comando:

rs0:PRIMARY> show dbs
local   6.0751953125GB

Para mudar para um novo banco de dados chamado mydb, use o seguinte comando:

Nota: Você não precisa criar o banco de dados antes de usá-lo pela primeira vez.

rs0:PRIMARY> use mydb
switched to db mydb

Para inserir os documentos em uma nova coleção denominada things dentro do novo banco de dados chamado mydb, faça o seguinte.

1.Criar dois documentos, chamados J e K, usando a seguinte seqüência de operações:

rs0:PRIMARY> j = { name : "mongo" }
{ "name" : "mongo" }
rs0:PRIMARY> k = { x : 3 }
{ "x" : 3 }

2.Insira o J e K documentos para a coleção things usando a seguinte seqüência de operações:

rs0:PRIMARY> db.things.insert( j )
rs0:PRIMARY> db.things.insert( k )

3.Confirme se os documentos de cobrança existem na coleção things pela emissão de esta consulta sobre a cobrança coisas:

rs0:PRIMARY> db.things.find()
{ "_id" : ObjectId("5162ef329e3aac3f0f6972de"), "name" : "mongo" }
{ "_id" : ObjectId("5162ef3c9e3aac3f0f6972df"), "x" : 3 }

Nota: Os valores de ID do documento serão diferente.

4.Sair do shell MongoDB:

rs0:PRIMARY> exit

Confira o Cluster de Redundância MongoDB

Vamos testar a resiliência do Cluster, simulando a falha de um nó do cluster.

Se a instância do MongoDB principal cair ou outros membros do cluster não conseguirem se conectar por causa de uma falha na rede, o cluster MongoDB irá iniciar o processo de eleição para eleger novo nó primário para o cluster.

1.Como usuário root, pare o serviço MongoDB na zona mongodb-node1:

root@global_zone:~# zlogin mongodb-node1
root@mongodb-node1:~# svcadm disable mongodb

2.Conecte-se à segunda zona MongoDB (mongodb-node2) e execute o shell do MongoDB:

root@global_zone:~# zlogin mongodb-node2
root@mongodb-node2:~# su - mongodb
mongodb@mongodb-node2:~ /usr/local/mongodb/bin/mongo

3.Execute o comando rs.status() para obter o status do conjunto de replicação.

rs0:PRIMARY> rs.status()

Você vai ver que mongodb-node2 foi promovido ao nó primário enquanto mongodb-node3 ainda é um nó secundário.

Nota: Durante o processo eletivo, diferentes hospedeiros podem ser eleitos como primário; por exemplo, mongodb-node3 poderia ser feito o membro primário e mongodb-node2 poderia ser um membro secundário. Você pode definir a prioridade, dando um membro do valor de prioridade mais elevada do que outros membros do conjunto. Consulte a documentação do MongoDB para um exemplo.

4. Coloque a instância MongoDB na zona mongodb-node1:

root@global_zone:~# zlogin mongodb-node1
root@mongodb-node1:~# svcadm enable mongodb

5.Verifique se o serviço MongoDB está instalado e funcionando:

root@mongodb-node1:~# svcs mongodb
       STATE          STIME    FMRI
       online         11:29:09 svc:/application/mongodb:default

6.Conecte-se à zona mongodb-node1 e execute o shell do MongoDB:

root@mongodb-node1:~# su - mongodb
mongodb@mongodb-node1:~ /usr/local/mongodb/bin/mongo

7.Execute o comando rs.status() para obter o status do conjunto de replicação.

rs0:SECONDARY> rs.status()

Você vai ver que mongodb-node1 é membro secundário agora e mongodb-node3 ainda é um membro do secundário.

Nota: O nível de associação do cluster pode ser diferente por causa do processo eletivo.

8.Sair do shell MongoDB:.

rs0:SECONDARY> exit

9.(Opcional) Você pode monitorar o MongoDB o processo eletivo, monitorando o arquivo de log MongoDB:

mongodb@mongodb-node1:~ tail -f /var/log/mongodb/mongod.log

Use DTrace para uma Melhor Observação do Sistema Operacional

O software MongoDB inclui ferramentas internas para analisar a carga de trabalho do banco de dados. No entanto, para obter uma imagem completa durante a análise de desempenho, você precisa observar o sistema operacional, além do banco de dados. O Oracle Solaris inclui um recurso de rastreamento dinâmico abrangente chamado DTrace. Usando esse recurso, você pode examinar o comportamento de ambos os programas do usuário e do próprio sistema operacional.

O exemplo a seguir demonstra como podemos usar DTrace para analisar um padrão de carga de trabalho de E/S durante a carga do banco de dados MongoDB. Vamos usar o DTrace Toolkit, que é uma coleção de scripts do DTrace localizados em /usr/dtrace/TDT /, para executar o disco de análise de desempenho de E / S.

1.Obter o nome da instância primária MongoDB usando o comando rs.status() a partir do shell do MongoDB. Você pode encontrar a mesma informação na página Status Replica Set em http:// <mongodb_IPaddress>: 28017/_replSet, como mostrado na Figura 2

[caption id="" align="aligncenter" width="548"]

Figura 2. Replica Set Status da Página[/caption]

2.Como o usuário mongodb, execute o seguinte comando na instância MongoDB primário para gerar carga no banco de dados MongoDB.

Nota: Neste exemplo, o principal é mongodb-node2; no entanto, ele pode ser um host diferente.

root@global_zone:~# zlogin mongodb-node2
root@mongodb-node2:~# su - mongodb
mongodb@mongodb-node2:~ /usr/local/mongodb/bin/mongo

rs0:PRIMARY> res = benchRun( {      ops : [ {          ns : "test.foo" ,          op : "insert" ,          doc : { y : { "#RAND_STRING" : [ 10 ] } }      } ] ,      parallel : 2 ,      seconds : 1000 ,      totals : true  } );

Listing 10. Generating Load

Para uma descrição detalhada da carga de trabalho ver http://www.mongodb.org/about/contributors/js-benchmarking-harness/.

3.De outro terminal na região global, execute o script iopattern DTrace, como mostrado na Listagem 11, para analisar o tipo de disco I/O de carga de trabalho:

root@global_zone:~# /usr/dtrace/DTT/iopattern
%RAN  %SEQ  COUNT   MIN    MAX    AVG     KR     KW
  84   16    196    512 1032704  42302      5   8092
  80   20     98   1024  189952  53221      0   5093
  72   28     68   4096   97280  58910      0   3912
  75   25     77   2048   96256  59910      2   4503
  75   25     72   4096   97280  58887      0   4140
  76   24    180    512 1046016 141405      0  24856
  87   13    110    512  181248  46982    115   4932
  75   25     73   4096   96768  58557    158   4016
  79   21     77   4096   97280  58387      0   4390
  73   27     75   4096  174080  57603    159   4060
  66   34    140    512 1048064 262645      0  35908
  84   16    120    512  437248  36369      0   4262
  79   21     72   4096   97280  58368      0   4104
  75   25     74   2560   97280  57489      2   4152

Listing 11. Analyzing the Workload

Os seguintes itens são mostrados na saída:

%RAN é a porcentagem de eventos de natureza aleatória.

%SEQ é a porcentagem de eventos de natureza seqüencial.

COUNT é o número de eventos de E/S.

MIN é o mínimo I / O tamanho do evento.

MAX é o tamanho I / O evento máximo.

AVG é o I / O tamanho médio do evento.

KR é o total de kilobytes lidos durante a amostra.

KW é o total de kilobytes escritos durante a amostra.

Conclusão

Neste artigo, vimos como podemos montar um ambiente Oracle Solaris Zones, e os ZFS, DTrace, e tecnologias de instalação de gestão de serviço do Oracle Solaris para construir, observar e gerenciar um cluster de banco de dados MongoDB.

domingo, 4 de maio de 2014