Plataforma de Big Data-Azkaban del sistema de programación

Introducción a Azkaban

Marco de programación de código abierto común:

• Linux Crontab: para usuarios individuales y pequeñas tareas
• Apache Oozie: potente y complejo marco de programación de tareas de Hadoop
• Azkaban: administrador de flujo de trabajo de código abierto, marco de programación ligero
• AirFlow: un marco de programación de lotes general desarrollado basado en Python
• Zenus: el sistema de programación de flujo de trabajo de código abierto basado en Hadoop de Ali
• EasyScheduler: sistema de programación de tareas de flujo de trabajo distribuido de código abierto nacional

Comparación del marco de programación de código abierto:

Introducción a Azkaban:

• Programador de tareas de flujo de trabajo por lotes distribuido de código abierto de Linkedin
• A través de una forma KV simple, genere trabajos y construya dependencias
• Admite el envío de tareas múltiples escalables a través del módulo de envío de tareas de complemento
• Documento oficial: https://azkaban.readthedocs.io/en/latest/

Ventajas de Azkaban:

• Puede establecer rápidamente la dependencia entre tareas y tareas a través de archivos de configuración de trabajos
• Proporciona un mecanismo de complemento modular y enchufable, admite de forma nativa shell, java, hive, etc.
• Basado en el desarrollo de Java, que proporciona Ajax Api, fácil para el desarrollo secundario

Escenarios aplicables de Azkaban:

• Realice el servicio de recopilación de datos de tiempo a través de Azkaban combinado con Datax
• Programe la ejecución de Shell, Java, Hive, Hadoop y otras tareas a través de Azkaban
• Desarrolle programas reutilizables, organícelos en flujos de trabajo a través de Azkaban y ejecute tareas de procesamiento por lotes
• Realice el desarrollo secundario de Azkaban a través de la interfaz para crear tareas, programar tareas y administrar tareas.
• Utilice Azkaban como parte de la plataforma de datos para proporcionar capacidades de programación de tareas.
• Mejorar las funciones de la plataforma de datos basadas en el manejo de excepciones, las alarmas de monitoreo y los registros de auditoría de Azkaban

---

Arquitectura y proceso de programación de Azkaban

El diagrama de la arquitectura de Azkaban es el siguiente:

• AzkabanServer: el servicio de gestión de Azkaban, que proporciona WebUI, responsable de la gestión de proyectos, gestión de derechos, ejecución de tiempos, seguimiento de progreso, registros de auditoría, etc.
• AzkabanExecutor: Responsable del envío y ejecución de workflows, recolectando logs de ejecución, es decir, el nodo de trabajo específico
• MySQL: almacena detalles del flujo de trabajo e información de estado de tareas y nodos, etc.

Entre ellos, se puede decir que AzkabanWebServer es el administrador principal de todo el sistema de flujo de trabajo de Azkaban. Es responsable de una serie de tareas como la gestión de proyectos, la autenticación de inicio de sesión del usuario, la ejecución regular del flujo de trabajo y el seguimiento del progreso de la ejecución del flujo de trabajo.

Al mismo tiempo, también proporciona una interfaz para las operaciones del servicio Web. Con esta interfaz, los usuarios pueden utilizar curl u otros métodos ajax para realizar operaciones relacionadas con azkaban. Las operaciones incluyen una serie de operaciones como el inicio de sesión del usuario, la creación de un proyecto, la carga del flujo de trabajo, la ejecución del flujo de trabajo, la consulta del progreso de ejecución del flujo de trabajo y la eliminación del flujo de trabajo, y los resultados de retorno de estas operaciones están todos en formato json.

Azkaban y conveniente, Azkaban utiliza .jobcomo un atributo clave extensiones de archivo para definir el flujo de trabajo de cada tarea, y utiliza el dependenciesatributo para definir las dependencias entre la cadena de trabajos. Estos archivos de trabajo y códigos asociados finalmente se *.zipcargan en el servidor web a través de la interfaz de usuario de Azkaban de alguna manera.

Azkaban tiene tres modos de implementación:

• Modo Solo: la base de datos incorporada, el servidor y el ejecutor están en el mismo proceso
• Dos modos: basado en la base de datos Mysq |, inicie un servidor y un ejecutor
• Modo múltiple: modo distribuido, un servidor y varios ejecutores

Diagrama de flujo de ejecución de Azkaban:

1. El usuario envía tareas al Webserver a través de la interfaz o API, y al Webserver de acuerdo con el estado del recurso de cada Ejecutor almacenado en la memoria caché (el Webserver tiene un hilo que atraviesa cada ejecutor activo para enviar solicitudes http para obtener la información del estado del recurso y almacenarlo en la memoria), según la estrategia de selección. (Incluyendo el estado de los recursos del ejecutor, el número de flujos de ejecución recientes, etc.) Seleccione un ejecutor apropiado para entregar el flujo de trabajo;
2. El ejecutor juzga si establecer la asignación granular de trabajos. Si no se establece la asignación granular de trabajos, todos los trabajos se ejecutarán en el ejecutor actual; si se establece la asignación granular de trabajos, el nodo actual se convertirá en el tomador de decisiones de la asignación de trabajos, es decir, el nodo de asignación;
3. El nodo de asignación obtiene la información del estado de los recursos de cada ejecutor del cuidador del zoológico y luego selecciona un ejecutor para asignar el trabajo de acuerdo con la estrategia;
4. El ejecutor asignado al trabajo se convierte en el nodo de ejecución, ejecuta el trabajo y luego actualiza la base de datos.

Proceso de interacción central de Azkaban:

1. AzkabanServer llama activamente a la API del ejecutor para obtener información de estado
2. Seleccione el servidor ejecutor que se ejecutará de acuerdo con las reglas de cálculo (número de tareas, recursos como memoria y CPU, y el tiempo asignado más recientemente)
3. Programe WorkFlow al ejecutor para su ejecución, el ejecutor ejecuta y monitorea las tareas

---

Instalación e implementación de Azkaban

• Sitio web oficial de Azkaban: https://azkaban.github.io
• Dirección de descarga de software: https://github.com/azkaban/azkaban
• Dirección oficial del complemento: https://github.com/azkaban/azkaban-plugins
• Dirección del documento oficial: https://azkaban.readthedocs.io/en/latest/getStarted.html

El modo de implementación de dos modos se adopta aquí , porque el modo Multi solo implementa múltiples ExecutorServers sobre esta base, es decir , agregar nodos ExecutorServer sobre la base de Two mode is Multi mode .

Compilar el código fuente de Azkaban

Primero, prepare Java y Maven:

[root@azkaban01 ~]# java -version
java version "1.8.0_261"
Java(TM) SE Runtime Environment (build 1.8.0_261-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.261-b12, mixed mode)
[root@azkaban01 ~]# mvn -v
Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Maven home: /usr/local/maven
Java version: 1.8.0_261, vendor: Oracle Corporation, runtime: /usr/local/jdk/1.8/jre
Default locale: zh_CN, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-1062.el7.x86_64", arch: "amd64", family: "unix"
[root@azkaban01 ~]# 

Instale algunas herramientas:

[root@azkaban01 ~]# yum install -y git gcc-c++

Luego, extraiga el código fuente de Azkaban de GitHub:

[root@hadoop01 ~]# cd /usr/local/src
[root@hadoop01 /usr/local/src]# git clone https://github.com/azkaban/azkaban.git

Ingrese el directorio de origen y settings.gradleagregue la configuración del almacén de complementos al comienzo del archivo:

[root@hadoop01 /usr/local/src]# cd azkaban
[root@azkaban01 /usr/local/src/azkaban]# vim settings.gradle 
pluginManagement {
    repositories {
        maven {
            url 'https://maven.aliyun.com/repository/gradle-plugin'
        }
        gradlePluginPortal()
    }
}

...

Luego modifique build.gradlela configuración del almacén en el archivo:

[root@azkaban01 /usr/local/src/azkaban]# vim build.gradle
buildscript {
  repositories {
    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter' }
    maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
    maven { url 'https://maven.aliyun.com/repository/google' }
    maven { url 'https://maven.aliyun.com/repository/jcenter' }
  }
  ...
}

...

allprojects {
  apply plugin: 'jacoco'

  repositories {
    mavenLocal()
    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter' }
    maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
    maven { url 'https://maven.aliyun.com/repository/google' }
    maven { url 'https://maven.aliyun.com/repository/jcenter' }
  }
}

gradle/wrapper/gradle-wrapper.propertiesEl archivo definirá la descarga de gradle de forma remota. Si no puede descargarlo, puede descargarlo de otras formas, luego cargarlo en el directorio correspondiente y especificar en el archivo para cargar el paquete de instalación de gradle desde el sistema de archivos local:

[root@azkaban01 /usr/local/src/azkaban]# vim gradle/wrapper/gradle-wrapper.properties
distributionUrl=file:///usr/local/src/gradle-4.6-all.zip

Después de completar la modificación anterior, puede ejecutar el siguiente comando para comenzar a compilar e instalar:

[root@azkaban01 /usr/local/src/azkaban]# ./gradlew build installDist -x test

Durante el proceso de empaquetado y compilación, se pueden informar los siguientes errores:

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':azkaban-web-server:nodeSetup'.
> Could not resolve all files for configuration ':azkaban-web-server:detachedConfiguration1'.
   > Could not download node-linux-x64.tar.gz (org.nodejs:node:8.10.0)
      > Could not get resource 'https://nodejs.org/dist/v8.10.0/node-v8.10.0-linux-x64.tar.gz'.
         > Read timed out

Esto se debe a que NodeJS no está instalado en el sistema y el módulo azkaban-web-server necesita NodeJS para compilar el código web. Este error se informará porque el paquete de instalación de NodeJS no se puede descargar de forma remota. La solución también es simple, simplemente instale NodeJS en el sistema. Proceder de la siguiente:

[root@azkaban01 /usr/local/src/azkaban]# curl --silent --location https://rpm.nodesource.com/setup_14.x | bash -
[root@azkaban01 /usr/local/src/azkaban]# yum install -y nodejs
[root@azkaban01 /usr/local/src/azkaban]# npm -v
6.14.8
[root@azkaban01 /usr/local/src/azkaban]# node -v
v14.15.0
[root@azkaban01 /usr/local/src/azkaban]# 

Configurar y npmutilizar el almacén de espejos de Taobao:

[root@azkaban01 /usr/local/src/azkaban]# npm config set registry https://registry.npm.taobao.org
[root@azkaban01 /usr/local/src/azkaban]# npm config get registry 
https://registry.npm.taobao.org/
[root@azkaban01 /usr/local/src/azkaban]# 

Abra el build.gradlearchivo en el módulo azkaban-web-server , modifique la configuración original del almacén y comente la configuración relacionada con el nodo. Como sigue:

[root@azkaban01 /usr/local/src/azkaban]# vim azkaban-web-server/build.gradle
buildscript {
    repositories {
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
        maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter' }
        maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/jcenter' }
        mavenCentral()
    }
    ...
}

...

//node {
    // Version of node to use.
    //version = '8.10.0'

    // Version of npm to use.
    //npmVersion = '5.6.0'

    // Base URL for fetching node distributions (change if you have a mirror).
    //distBaseUrl = 'https://nodejs.org/dist'

    // If true, it will download node using above parameters.
    // If false, it will try to use globally installed node.
    //download = true

    // Set the work directory for unpacking node
    //workDir = file("${project.buildDir}/nodejs")

    // Set the work directory where node_modules should be located
    //nodeModulesDir = file("${project.projectDir}")
//}

Luego, vuelva a ejecutar el comando de compilación del paquete:

[root@azkaban01 /usr/local/src/azkaban]# ./gradlew build installDist -x test

Finalmente empaquetado y compilado con éxito:

En este momento build/distributions, puede ver el paquete de instalación empaquetado en el directorio del componente principal :

[root@azkaban01 /usr/local/src/azkaban]# ls azkaban-exec-server/build/distributions/
azkaban-exec-server-0.1.0-SNAPSHOT.tar.gz  azkaban-exec-server-0.1.0-SNAPSHOT.zip
[root@azkaban01 /usr/local/src/azkaban]# ls azkaban-web-server/build/distributions/
azkaban-web-server-0.1.0-SNAPSHOT.tar.gz  azkaban-web-server-0.1.0-SNAPSHOT.zip
[root@azkaban01 /usr/local/src/azkaban]# ls azkaban-db/build/distributions/
azkaban-db-0.1.0-SNAPSHOT.tar.gz  azkaban-db-0.1.0-SNAPSHOT.zip
[root@azkaban01 /usr/local/src/azkaban]# 

Instalar e implementar Azkaban

Descomprime el paquete de instalación:

[root@azkaban01 /usr/local/src/azkaban]# mkdir /usr/local/azkaban
[root@azkaban01 /usr/local/src/azkaban]# tar -zxvf azkaban-db/build/distributions/azkaban-db-0.1.0-SNAPSHOT.tar.gz -C /usr/local/azkaban
[root@azkaban01 /usr/local/src/azkaban]# tar -zxvf azkaban-exec-server/build/distributions/azkaban-exec-server-0.1.0-SNAPSHOT.tar.gz -C /usr/local/azkaban
[root@azkaban01 /usr/local/src/azkaban]# tar -zxvf azkaban-web-server/build/distributions/azkaban-web-server-0.1.0-SNAPSHOT.tar.gz -C /usr/local/azkaban

Para mayor comodidad, cambie el nombre del directorio descomprimido:

[root@azkaban01 /usr/local/src/azkaban]# cd /usr/local/azkaban/
[root@azkaban01 /usr/local/azkaban]# mv azkaban-db-0.1.0-SNAPSHOT/ azkaban-db
[root@azkaban01 /usr/local/azkaban]# mv azkaban-exec-server-0.1.0-SNAPSHOT/ azkaban-exec-server
[root@azkaban01 /usr/local/azkaban]# mv azkaban-web-server-0.1.0-SNAPSHOT/ azkaban-web-server

Primero, cree una azkabanbase de datos en MySQL y luego importe los archivos en el directorio azkaban-dbcreate-all-sql-0.1.0-SNAPSHOT.sql en MySQL:

create database azkaban;
use azkaban;
source /usr/local/azkaban/azkaban-db/create-all-sql-0.1.0-SNAPSHOT.sql

Luego configure azkaban-exec-server :

[root@azkaban01 /usr/local/azkaban]# cd azkaban-exec-server/
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# vim conf/azkaban.properties
# webserver的连接地址
azkaban.webserver.url=http://localhost:8081

database.type=mysql
mysql.port=3306
mysql.host=192.168.1.11
# MySQL8.x需要加时区参数，5.x则不需要
mysql.database=azkaban?serverTimezone=Asia/Shanghai
mysql.user=root
mysql.password=123456a.
mysql.numconnections=100

Dado que azkaban-exec-server usa la versión 5.x del controlador MySQL de forma predeterminada, y la versión MySQL que implementé es la versión 8.x, tengo que reemplazar el paquete del controlador MySQL:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# cp /usr/local/src/mysql-connector-java-8.0.21.jar lib/
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# rm -rf lib/mysql-connector-java-5.1.28.jar 

Inicie azkaban-exec-server:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# bin/start-exec.sh

Compruebe si el proceso azkaban-exec-server se está ejecutando normalmente:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# jps
2005 Jps
1982 AzkabanExecutorServer
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# netstat -lntp |grep 1982
tcp6       0      0 :::35195                :::*               LISTEN      1982/java           
tcp6       0      0 :::36304                :::*               LISTEN      1982/java           
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# 

Active manualmente Executor Server a través de API:

$ curl http://localhost:35195/executor?action=activate

Luego configure azkaban-webserver :

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# cd ../azkaban-web-server/
[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# vim conf/azkaban.properties 
database.type=mysql
mysql.port=3306
mysql.host=192.168.1.11
# MySQL8.x需要加时区参数，5.x则不需要
mysql.database=azkaban?serverTimezone=Asia/Shanghai
mysql.user=root
mysql.password=123456a.
mysql.numconnections=100

Reemplace el paquete del controlador MySQL:

[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# cp /usr/local/src/mysql-connector-java-8.0.21.jar lib/
[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# rm -rf lib/mysql-connector-java-5.1.28.jar

Inicie azkaban-webserver:

[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# bin/start-web.sh

Compruebe si el proceso azkaban-webserver se está ejecutando normalmente:

[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# jps
2201 Jps
2172 AzkabanWebServer
1982 AzkabanExecutorServer
[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# netstat -lntp |grep 2172
tcp6       0      0 :::46136                :::*              LISTEN      2172/java           
tcp6       0      0 :::8081                 :::*              LISTEN      2172/java           
[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# 

Use el navegador para visitar la página del servidor web, ingresará a la página de inicio de sesión, el nombre de usuario y la contraseña predeterminados son azkaban:

• La configuración relacionada con el usuario del servidor web se puede conf/azkaban-users.xmlmodificar en el archivo

Inicie sesión correctamente para ingresar a la página de inicio, de la siguiente manera:

---

Enviar tarea de Azkaban

Documentos oficiales sobre Job:

• https://azkaban.readthedocs.io/en/latest/createFlows.html#job-config

Flujo de trabajo de Azkaban:

• Proyecto: El concepto abstracto de Azkaban, el proyecto. Un proyecto incluye múltiples flujos
• Flujo: proceso, un flujo contiene múltiples trabajos y dependencias de trabajo
• Trabajo: tareas específicas, como command, java, hive, hadoopJava, etc.

Tipo de tarea de Azkaban:

• Azkaban tiene un repositorio de complementos independiente , que debe compilarse
• Los diferentes complementos de trabajo se crean sobre la base de comandos.
• El tipo de comando es un tipo de tarea de Azkaban versátil, porque puede implementar operaciones arbitrarias en el script de shell llamando al script de shell a través del comando

Tarea única

Enviemos una tarea de comando simple a través de la interfaz visual de WebServer. Primero, cree un archivo de definición de tarea:

$ vim cmd_test.job
type=command
command=sh job1.sh

Escriba un script de shell simple:

$ vim job1.sh
#!/bin/sh
echo "hello azkaban"

Combine estos dos archivos en un paquete zip:

Cree un proyecto en la página del servidor web:

Sube el paquete comprimido:

Una vez que la carga se haya realizado correctamente, haga clic en "Ejecutar flujo" -> "Programar" y crontabdefina la hora programada mediante la expresión de configuración :

Después de configurar la expresión y hacer clic en "Programar", puede ver las tareas programadas en "Programación":

Haga clic en "cmd_test" debajo de "Flujo" para ver la ejecución de la tarea:

Trabajos multiples

Lo anterior demuestra la definición, envío y programación de una sola tarea. A continuación, se demuestra la definición, envío y programación de múltiples tareas, y existen dependencias entre estas múltiples tareas, es decir, el orden de programación entre tareas. Primero, cree un archivo de tarea:

$ vim job1.job
type=command
command=sh job1.sh

----------

$ vim job2.job
type=command
command=sh job2.sh
# 依赖job1，当job1调度执行完才会执行job2
dependencies=job1

----------

$ vim job3.job
type=command
command=sh job3.sh
dependencies=job1

----------

$ vim job4.job
type=command
command=sh job4.sh
dependencies=job2,job3

Escriba el script de shell correspondiente a la tarea:

$ vim job1.sh
#!/bin/sh
echo "job1 exec over"

----------

$ vim job2.sh
#!/bin/sh
echo "job2 exec over"

----------

$ vim job3.sh
#!/bin/sh
echo "job3 exec over"

----------

$ vim job4.sh
#!/bin/sh
echo "job4 exec over"

De manera similar, coloque estos archivos en un paquete comprimido:

Cree un nuevo proyecto en WebServer y cargue el paquete comprimido:

Ahora expanda el trabajo para ver una estructura de árbol:

Haga clic en "Ejecutar flujo", puede ver el gráfico de dependencia entre tareas:

Haga clic en "Ejecutar" para ejecutar la tarea. Este método es una ejecución única y no se programará para su ejecución. Todos los nodos de tareas se ejecutan correctamente, los nodos de la figura son todos verdes:

En la "Lista de trabajos" puede ver la lista de tareas y alguna información de ejecución:

---

Agente de usuario de Azkaban

Usuarios de proxy de Azkaban:

• Azkaban puede ejecutar comandos en nombre de otros usuarios de Linux
• El control de permisos de Hadoop se puede lograr a través del modo de usuario proxy

Compile el módulo de agente de usuario:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# mkdir extlib
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# gcc /usr/local/src/azkaban/az-exec-util/src/main/c/execute-as-user.c -o extlib/execute-as-user
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# chmod 6050 extlib/execute-as-user

Cree un archivo de configuración:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# vim plugins/jobtypes/commonprivate.properties
execute.as.user=true
azkaban.native.lib=/usr/local/azkaban/azkaban-exec-server/extlib/
azkaban.group.name=root

Reinicie ExecuteServer:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# bin/shutdown-exec.sh 
Killing executor. [pid: 1982], attempt: 1
shutdown succeeded
[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# bin/start-exec.sh 

Activar ExecutorServer:

$ curl http://localhost:46176/executor?action=activate

• Consejos: el puerto de ExecutorServer es diferente cada vez que se reinicia

Reinicie WebServer:

[root@azkaban01 /usr/local/azkaban/azkaban-exec-server]# cd ../azkaban-web-server/
[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# bin/shutdown-web.sh 
Killing web-server. [pid: 2172], attempt: 1
shutdown succeeded
[root@azkaban01 /usr/local/azkaban/azkaban-web-server]# bin/start-web.sh

A continuación, envíe la tarea para probarla y cree un archivo de definición de tarea:

$ vim proxy.job
type=command
command=sh test.sh

Escriba el script de shell correspondiente:

$ vim test.sh
#!/bin/sh
echo "----------------"
whoami
echo "----------------"

Conviértalo en un paquete comprimido:

Cree "Proyecto" y cargue el paquete comprimido:

Luego haga clic en "Ejecutar flujo" -> "Ejecutar" para ejecutar la tarea, y encontrará que la ejecución falló:

Al mirar el registro, puede ver que el usuario proxy'azkaban 'no está autorizado:

Vaya al sistema operativo y cree un nuevo usuario:

$ useradd hadoop

• Consejos: Azkaban prohíbe a los usuarios raíz de proxy de forma predeterminada

Modifique el archivo de configuración de la tarea y especifique el usuario proxy de la siguiente manera:

$ vim proxy.job
type=command
command=sh test.sh
user.to.proxy=hadoop

Luego, vuelva a empaquetar y cargar, y vuelva a realizar la tarea. La tarea se ejecutó con éxito esta vez y el registro de salida es el siguiente:

Los ejemplos anteriores son todos la ejecución simple de un script de shell.Si realmente desea programar una tarea de MR, en realidad es muy simple, solo necesita configurar y ejecutar el comando correspondiente. El siguiente ejemplo:

type=command
command=yarn jar /soft/home/hadoop-2.8.5/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.8.5.jar pi 16 1000
user.to.proxy=hadoop

---

Acerca de Java Operation Azkaban Api

Además de la creación de proyectos, carga / envío de tareas y otras operaciones en la interfaz visual de Azkaban WebServer, Azkaban también admite estas operaciones a través de la API HTTP. Porque si queremos desarrollar nuestra propia plataforma de big data, es posible que no usemos la interfaz visual de Azkaban WebServer, pero esperamos interactuar con Azkaban en nuestra interfaz de plataforma de big data para completar la gestión de la programación de tareas. Por lo tanto, Azkaban proporciona compatibilidad con HTTP Api, para que podamos integrarnos fácilmente con la plataforma de desarrollo propio.

La dirección del documento oficial de Azkaban Api es la siguiente:

• https://azkaban.readthedocs.io/en/latest/ajaxApi.html

He preparado un repositorio de código de muestra aquí, simplemente puede consultarlo:

• https://gitee.com/Zero-One/azkaban-api-demo