TOC

Fluxo de dados do Spring Cloud com Apache Spark

Fluxo de dados do Spring Cloud com Apache Spark

1. Introdução

Spring Cloud Data Flow é um kit de ferramentas para a construção de integração de dados e pipelines de processamento de dados em tempo real.

Pipelines, neste caso, são aplicativos Spring Boot construídos com o uso de estruturasSpring Cloud Stream ouSpring Cloud Task.

Neste tutorial, mostraremos como usar o Spring Cloud Data Flow comApache Spark.

2. Servidor local de fluxo de dados

Primeiro, precisamos executarthe Data Flow Server para poder implantar nossos trabalhos.

Para executar o servidor de fluxo de dados localmente, precisamos criar um novo projeto comthe spring-cloud-starter-dataflow-server-local dependency: 


    org.springframework.cloud
    spring-cloud-starter-dataflow-server-local
    1.7.4.RELEASE

Depois disso, precisamos anotar a classe principal no servidor com@EnableDataFlowServer: 

@EnableDataFlowServer
@SpringBootApplication
public class SpringDataFlowServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(
          SpringDataFlowServerApplication.class, args);
    }
}

Assim que executarmos este aplicativo, teremos um servidor de fluxo de dados local na porta 9393.

3. Criando um projeto

Vamoscreate a Spark Job como um aplicativo local autônomo para que não precisemos de nenhum cluster para executá-lo.

3.1. Dependências

Primeiro, vamos adicionarthe Spark dependency: 


    org.apache.spark
    spark-core_2.10
    2.4.0

3.2. Criando um trabalho

E para o nosso trabalho, vamos aproximar o pi: 

public class PiApproximation {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("examplePIApproximation");
        JavaSparkContext context = new JavaSparkContext(conf);
        int slices = args.length >= 1 ? Integer.valueOf(args[0]) : 2;
        int n = (100000L * slices) > Integer.MAX_VALUE ? Integer.MAX_VALUE : 100000 * slices;

        List xs = IntStream.rangeClosed(0, n)
          .mapToObj(element -> Integer.valueOf(element))
          .collect(Collectors.toList());

        JavaRDD dataSet = context.parallelize(xs, slices);

        JavaRDD pointsInsideTheCircle = dataSet.map(integer -> {
           double x = Math.random() * 2 - 1;
           double y = Math.random() * 2 - 1;
           return (x * x + y * y ) < 1 ? 1: 0;
        });

        int count = pointsInsideTheCircle.reduce((integer, integer2) -> integer + integer2);

        System.out.println("The pi was estimated as:" + count / n);

        context.stop();
    }
}

4. Shell de fluxo de dados

O Data Flow Shell é um aplicativo queenable us to interact with the server. O Shell usa os comandos DSL para descrever os fluxos de dados.

Parause the Data Flow Shell, precisamos criar um projeto que nos permitirá executá-lo. Primeiro, precisamos dethe spring-cloud-dataflow-shell dependency: 


    org.springframework.cloud
    spring-cloud-dataflow-shell
    1.7.4.RELEASE

Depois de adicionar a dependência, podemos criar a classe que executará nosso shell de fluxo de dados: 

@EnableDataFlowShell
@SpringBootApplication
public class SpringDataFlowShellApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringDataFlowShellApplication.class, args);
    }
}

5. Implantando o projeto

Para implantar nosso projeto, usaremos o chamado executor de tarefas que está disponível para Apache Spark em três versões:cluster,yarn eclient. Vamos prosseguir com a versãoclient local.

O executor de tarefas é o que executa nosso trabalho do Spark.

Para fazer isso, primeiro precisamosregister our task using Data Flow Shell: 

app register --type task --name spark-client --uri maven://org.springframework.cloud.task.app:spark-client-task:1.0.0.BUILD-SNAPSHOT

A tarefa permite especificar vários parâmetros diferentes, alguns deles são opcionais, mas alguns parâmetros são necessários para implantar o trabalho do Spark corretamente:

  • spark.app-class, a classe principal de nosso trabalho enviado

  • spark.app-jar, um caminho para o frasco de gordura que contém nosso trabalho

  • spark.app-name, o nome que será usado em nosso trabalho

  • spark.app-args, os argumentos que serão passados ​​para o trabalho

Podemos usar a tarefa registradaspark-client para enviar nosso trabalho, lembrando de fornecer os parâmetros necessários: 

task create spark1 --definition "spark-client \
  --spark.app-name=my-test-pi --spark.app-class=com.example.spring.cloud.PiApproximation \
  --spark.app-jar=/apache-spark-job-0.0.1-SNAPSHOT.jar --spark.app-args=10"

Observe quespark.app-jar é o caminho para o jarro de gordura com nosso trabalho.

Após a criação bem-sucedida da tarefa, podemos executá-la com o seguinte comando: 

task launch spark1

Isso invocará a execução de nossa tarefa.

6. Sumário

Neste tutorial, mostramos como usar a estrutura do Spring Cloud Data Flow para processar dados com o Apache Spark. Mais informações sobre a estrutura Spring Cloud Data Flow podem ser encontradas emdocumentation.

Todas as amostras de códigocan be found on GitHub.

Related