Toute commande pour être actif namenode pour nameservice dans hadoop?

Trouvé ceci:

https://gist.github.com/cnauroth/7ff52e9f80e7d856ddb3

Cela fonctionne hors de la boîte sur mon CDH5 namenodes, bien que je ne suis pas sûr d'autres distributions hadoop aura http://namenode:50070/jmx disponible - si non, je pense qu'il peut être ajouté par le déploiement de Jolokia.

Exemple:

curl 'http://namenode1.example.com:50070/jmx?qry=Hadoop:service=NameNode,name=NameNodeStatus'
{
  "beans" : [ {
    "name" : "Hadoop:service=NameNode,name=NameNodeStatus",
    "modelerType" : "org.apache.hadoop.hdfs.server.namenode.NameNode",
    "State" : "active",
    "NNRole" : "NameNode",
    "HostAndPort" : "namenode1.example.com:8020",
    "SecurityEnabled" : true,
    "LastHATransitionTime" : 1436283324548
  } ]

Donc, en lançant une requête http à chaque namenode (ce devrait être rapide), on peut comprendre que l'on est celui qui est actif.

Il est également intéressant de noter que si vous parlez WebHDFS API REST inactif namenode, vous obtiendrez un 403 Forbidden et le JSON suivants:

{"RemoteException":{"exception":"StandbyException","javaClassName":"org.apache.hadoop.ipc.StandbyException","message":"Operation category READ is not supported in state standby"}}

Après la lecture de toutes les réponses aucun ne semble combiner les trois étapes de:

1. Identifier les namenodes du cluster.
2. Résoudre les noms de nœud d'hôte:port.
3. Vérification de l'état de chaque nœud (sans avoir besoin de
   cluster admin privs).

Solution ci-dessous combine hdfs getconf appels et service JMX appel à l'état d'un noeud.

#!/usr/bin/env python

from subprocess import check_output
import urllib, json, sys

def get_name_nodes(clusterName):
    ha_ns_nodes=check_output(['hdfs', 'getconf', '-confKey',
        'dfs.ha.namenodes.' + clusterName])
    nodes = ha_ns_nodes.strip().split(',')
    nodeHosts = []
    for n in nodes:
        nodeHosts.append(get_node_hostport(clusterName, n))

    return nodeHosts

def get_node_hostport(clusterName, nodename):
    hostPort=check_output(
        ['hdfs','getconf','-confKey',
         'dfs.namenode.rpc-address.{0}.{1}'.format(clusterName, nodename)])
    return hostPort.strip()

def is_node_active(nn):
    jmxPort = 50070
    host, port = nn.split(':')
    url = "http://{0}:{1}/jmx?qry=Hadoop:service=NameNode,name=NameNodeStatus".format(
            host, jmxPort)
    nnstatus = urllib.urlopen(url)
    parsed = json.load(nnstatus)

    return parsed.get('beans', [{}])[0].get('State', '') == 'active'

def get_active_namenode(clusterName):
    for n in get_name_nodes(clusterName):
        if is_node_active(n):
            return n

clusterName = (sys.argv[1] if len(sys.argv) > 1 else None)
if not clusterName:
    raise Exception("Specify cluster name.")

print 'Cluster: {0}'.format(clusterName)
print "Nodes: {0}".format(get_name_nodes(clusterName))
print "Active Name Node: {0}".format(get_active_namenode(clusterName))

Dans une Haute Disponibilité de votre cluster Hadoop, il y aura 2 namenodes - un actif et un mode de veille.

Pour trouver l'actif namenode, nous pouvons essayer d'exécuter le test de hdfs commande sur chacun des namenodes et de trouver le nom de la matière active nœud correspondant à l'exécution réussie.

Ci-dessous la commande s'exécute correctement si le nom de nœud est actif et échoue si c'est un nœud en attente.

hadoop fs -test -e hdfs://<Name node>/

Script Unix

active_node=''
if hadoop fs -test -e hdfs://<NameNode-1>/; then
active_node='<NameNode-1>'
elif hadoop fs -test -e hdfs://<NameNode-2>/; then
active_node='<NameNode-2>'
fi

echo "Active Dev Name node : $active_node"

#!/usr/bin/python

import subprocess
import sys
import os, errno


def getActiveNameNode () :

    cmd_string="hdfs getconf -namenodes"
    process = subprocess.Popen(cmd_string, shell=True, stdout=subprocess.PIPE)
    out, err = process.communicate()
    NameNodes = out
    Value = NameNodes.split(" ")
    for val in Value :
        cmd_str="hadoop fs -test -e hdfs://"+val
        process = subprocess.Popen(cmd_str, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        out, err = process.communicate()
        if (err != "") :
            return val

def main():

    out = getActiveNameNode()
    print(out)

if __name__ == '__main__':
    main()