Adesso abbiamo imparato molto su DAPR.
Questi sono alcuni dei miei articoli precedenti su Flussi di lavoro DAPR E Conversazione DAPR AI componenti. Oggi discuteremo di lavori, un altro importante elemento elegante dell’ecosistema DAPR.
Molte volte, dovrai eseguire flussi di lavoro in un programma. Per esempio,
- Backup di file regolari: I backup periodici aiutano a ripristinare i dati quando c’è un fallimento. Quindi, tu potrebbe programmare uno per eseguire il backup dei dati su base regolare.
- Eseguire compiti di manutenzione: Cose come la pulizia dei file, i nodi VM di riciclaggio e I dati di elaborazione batch sono Alcuni Altri scenari in cui i lavori DAPR possono aiutare.
Architettura di lavoro
- MyApp è l’applicazione Java che lo faremo essere creando Oggi, responsabile della pianificazione e della registrazione del lavoro.
- Quando si crea il lavoro cron, l’applicazione deve Registra un endpoint di callback in modo che il runtime DAPR possa invocarlo all’ora programmata.
- L’endpoint dovrebbe essere una richiesta submit con un modello URL simile a
/jobs/{jobName}dove Jobname corrisponde al nome utilizzato durante la registrazione del lavoro.
- L’endpoint dovrebbe essere una richiesta submit con un modello URL simile a
Ora, diamo un’occhiata a una dimostrazione pratica. Nell’app di esempio, creeremo un semplice lavoro che funziona ogni 10 secondi. L’URL di callback registrato stamperà il nome del lavoro invocato.
Perché abbiamo usato .NET SDK in tutti gli articoli precedenti, questa volta Andremo con il Java-SDK.
Passaggio 1
Scarica la CLI DAPR e installalo. C’è anche un MSI che potresti utilizzare per installare l’ultima versione qui: https://github.com/dapr/cli/releases.
powershell -Command "iwr -useb https://uncooked.githubusercontent.com/dapr/cli/grasp/set up/set up.ps1 | iex"
Passaggio 2
Verificare l’installazione utilizzando il comando seguente.
Assicurati di avere anche Docker in esecuzione perché i obtain della CLI Docker Immagini di runtime, scheduler e servizi di collocamento.
Successivamente, è tempo di impostare il app. Per questo, creeremo a Maven Progetta e usa le dipendenze DAPR Maven. Gradle potrebbe essere un’altra scelta.
Passaggio 3
Crea un Progetto Maven. Aggiungi la seguente dipendenza DAPR advert esso.
io.dapr
dapr-sdk
${challenge.model}
Abbiamo anche discusso di registrare un endpoint che lo scheduler potrebbe chiamare. In questo caso, stiamo usando il framework Spring per registrare un endpoint. Potresti anche usare jax-rs o Qualsiasi altro quadro a tua scelta.
org.springframework.boot
spring-boot-starter-web
${springboot.model}
Passaggio 4
Logica app per registrare il lavoro.
import io.dapr.consumer.DaprClientBuilder;
import io.dapr.consumer.DaprPreviewClient;
import io.dapr.consumer.area.GetJobRequest;
import io.dapr.consumer.area.GetJobResponse;
import io.dapr.consumer.area.JobSchedule;
import io.dapr.consumer.area.ScheduleJobRequest;
import io.dapr.config.Properties;
import io.dapr.config.Property;
import java.util.Map;
public class DemoJobsClient {
/**
* The principle methodology of this app to register and fetch jobs.
*/
public static void most important(String() args) throws Exception {
Map, String> overrides = Map.of(
Properties.HTTP_PORT, "3500",
Properties.GRPC_PORT, "51439"
);
strive (DaprPreviewClient consumer = new DaprClientBuilder().withPropertyOverrides(overrides).buildPreviewClient()) {
// Schedule a job.
System.out.println("**** Scheduling a Job with title dapr-jobs *****");
ScheduleJobRequest scheduleJobRequest = new ScheduleJobRequest("dapr-job",
JobSchedule.fromString("*/10 * * * * *")).setData("Good day World!".getBytes());
consumer.scheduleJob(scheduleJobRequest).block();
System.out.println("**** Scheduling job with title dapr-jobs accomplished *****");
// Get a job.
System.out.println("**** Retrieving a Job with title dapr-jobs *****");
GetJobResponse getJobResponse = consumer.getJob(new GetJobRequest("dapr-job")).block();
// Delete a job.
DeleteJobResponse deleteJobResponse = consumer.deleteJob(new DeleteJobRequest("dapr-job")).block();
}
}
} - Abbiamo creato una semplice classe Java con un metodo principale. Perché i lavori sono ancora una funzione di anteprima,
DaprPreviewClientviene utilizzato per programmare, ottenere o eliminare un lavoro. - IL
ScheduleJobRequestIl costruttore prende In due parametri, il nome del lavoro e l’espressione di Cron, che in questo caso deve funzionare ogni 10 secondi. - Infine, chiamiamo il
scheduleJob()metodo che lo farà Pianifica un lavoro con il runtime di Dapper. - IL
getJob()Il metodo viene utilizzato per recuperare i dettagli del lavoro di un lavoro esistente.
Passaggio 5
Registra un endpoint di callback.
import org.springframework.internet.bind.annotation.PathVariable;
import org.springframework.internet.bind.annotation.PostMapping;
import org.springframework.internet.bind.annotation.RequestBody;
import org.springframework.internet.bind.annotation.RestController;
import reactor.core.writer.Mono;
/**
* SpringBoot Controller to deal with jobs callback.
*/
@RestController
public class JobsController {
/**
* Handles jobs callback from Dapr.
*
* @param jobName title of the job.
* @param payload knowledge from the job if payload exists.
* @return Empty Mono.
*/
@PostMapping("/job/{jobName}")
public Mono handleJob(@PathVariable("jobName") String jobName,
@RequestBody(required = false) byte() payload) {
System.out.println("Job Identify: " + jobName);
System.out.println("Job Payload: " + new String(payload));
return Mono.empty();
}
} Una volta che è ora di eseguire il lavoro programmato, il runtime DAPR chiamerà il seguente endpoint. È possibile definire un postmapping con il nome del lavoro specifico come “/lavoro/Dapr-job” o utilizzare un parametro del percorso come abbiamo fatto sopra.
Passaggio 6
Scrivi il file di avvio per l’app Spring Boot.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* Spring Boot software to display Dapr Jobs callback API.
*
* This software demonstrates easy methods to use Dapr Jobs API with Spring Boot.
*
*/
@SpringBootApplication
public class DemoJobsSpringApplication {
public static void most important(String() args) throws Exception {
SpringApplication.run(DemoJobsSpringApplication.class, args);
}
}
Passaggio 7
Ora è tempo di eseguire l’applicazione. Vai alla cartella del progetto Maven ed esegui il seguente comando. Cambia il nome del barattolo e della classe, se necessario.
dapr run --app-id myapp --app-port 8080 --dapr-http-port 3500 --dapr-grpc-port 51439 --log-level debug -- java -jar goal/dapr-java-sdk-examples-exec.jar io.dapr.examples.jobs.DemoJobsSpringApplication
Output dal comando.
Passaggio 8
Infine, esegui il DemoJobsClient.
java -jar goal/dapr-java-sdk-examples-exec.jar io.dapr.examples.jobs.DemoJobsClient
Output dal comando.
**** Scheduling a Job with title dapr-jobs *****Tornando all’altra finestra in cui eseguiamo il comando dal passaggio 8, noterai il seguente registro della console.
== APP == Job Identify: dapr-job
== APP == Job Payload: Good day World!Conclusione
DAPR Jobs è uno strumento potente che può aiutarti a pianificare i carichi di lavoro senza dover prendere la complessità dell’uso delle librerie CRON. Vai a provarlo.
