Questa pagina fornisce le best practice per lo sviluppo e il test della pipeline Dataflow.
Panoramica
Il modo in cui viene implementato il codice della pipeline influisce notevolmente sul rendimento della pipeline in produzione. Per aiutarti a creare codice della pipeline che funzioni in modo corretto ed efficiente, questo documento illustra quanto segue:
- Runner di pipeline per supportare l'esecuzione del codice nelle diverse fasi di sviluppo e di implementazione.
- Ambienti di deployment che consentono di eseguire pipeline in fase di sviluppo, test, pre-produzione e produzione.
- Modelli e codice di pipeline open source che puoi utilizzare così come sono o come base per nuove pipeline per accelerare lo sviluppo del codice.
- Un approccio basato sulle best practice per il test del codice della pipeline. Innanzitutto, questo documento fornisce una panoramica che include l'ambito e la relazione tra diversi tipi di test, come test di unità, test di integrazione e test end-to-end. In secondo luogo, ogni tipo di test viene esplorato in dettaglio, inclusi i metodi per creare e integrare i dati di test e i runner della pipeline da utilizzare per ogni test.
Runner della pipeline
Durante lo sviluppo e i test, utilizzi diversi runner Apache Beam per eseguire il codice della pipeline. L'SDK Apache Beam fornisce un runner diretto per lo sviluppo e i test locali. Gli strumenti di automazione della release possono anche utilizzare Direct Runner per i test di unità e di integrazione. Ad esempio, puoi utilizzare il Runner diretto all'interno della pipeline di integrazione continua (CI).
Le pipeline di cui viene eseguito il deployment in Dataflow utilizzano Dataflow Runner, che esegue la pipeline in ambienti simili alla produzione. Inoltre, puoi utilizzare Dataflow Runner per test di sviluppo ad hoc e per test di pipeline end-to-end.
Sebbene questa pagina si concentri sull'esecuzione di pipeline create utilizzando l'SDK Apache Beam Java, Dataflow supporta anche le pipeline Apache Beam sviluppate utilizzando Python e Go. Gli SDK Apache Beam Java, Python e Go sono generalmente disponibili per Dataflow. Gli sviluppatori SQL possono anche utilizzare Apache Beam SQL per creare pipeline che utilizzano dialetti SQL familiari.
Configura un ambiente di deployment
Per separare utenti, dati, codice e altre risorse nelle diverse fasi di sviluppo, crea ambienti di deployment. Se possibile, per fornire ambienti isolati per le diverse fasi di sviluppo della pipeline, utilizza progetti Google Cloud distinti.
Le sezioni seguenti descrivono un insieme tipico di ambienti di implementazione.
Ambiente locale
L'ambiente locale è la workstation di uno sviluppatore. Per lo sviluppo e i test rapidi, utilizza Direct Runner per eseguire il codice della pipeline localmente.
Le pipeline eseguite localmente utilizzando il programma di esecuzione diretto possono interagire con le risorse Google Cloud remote, ad esempio gli argomenti Pub/Sub o le tabelle BigQuery. Assegna ai singoli sviluppatori progetti Google Cloud separati in modo che abbiano una sandbox per i test ad hoc con i servizi Google Cloud.
Alcuni servizi Google Cloud, come Pub/Sub e Bigtable, forniscono emulatori per lo sviluppo locale. Puoi utilizzare questi emulatori con Direct Runner per abilitare lo sviluppo e il test locali end-to-end.
Ambiente sandbox
L'ambiente sandbox è un progetto Google Cloud che fornisce agli sviluppatori accesso ai servizi Google Cloud durante lo sviluppo del codice. Gli sviluppatori di pipeline possono condividere un progetto Google Cloud con altri sviluppatori o utilizzare i propri progetti individuali. L'utilizzo di singoli progetti riduce la complessità della pianificazione relativa all'utilizzo delle risorse condivise e alla gestione delle quote.
Gli sviluppatori utilizzano l'ambiente sandbox per eseguire l'esecuzione di pipeline ad hoc con Dataflow Runner. L'ambiente sandbox è utile per eseguire il debug e testare il codice su un esecuzione di produzione durante la fase di sviluppo del codice. Ad esempio, l'esecuzione di pipeline ad hoc consente agli sviluppatori di:
- Osserva l'effetto delle modifiche al codice sul comportamento di scalabilità.
- Scopri le potenziali differenze tra il comportamento di DirectRunner e DataflowRunner.
- Scopri come Dataflow applica le ottimizzazioni del grafo.
Per i test ad hoc, gli sviluppatori possono eseguire il deployment del codice dal proprio ambiente locale per eseguire Dataflow all'interno dell'ambiente sandbox.
Ambiente di preproduzione
L'ambiente di preproduzione è destinato alle fasi di sviluppo che devono essere eseguite in condizioni simili alla produzione, ad esempio i test end-to-end. Utilizza un progetto distinto per l'ambiente di preproduzione e configuralo in modo che sia il più simile possibile a quello di produzione. Analogamente, per consentire test end-to-end con una scalabilità simile a quella di produzione, imposta le quote dei progetti Google Cloud per Dataflow e altri servizi il più simili possibile all'ambiente di produzione.
A seconda dei requisiti, puoi suddividere ulteriormente la preproduzione in più ambienti. Ad esempio, un ambiente di controllo qualità può supportare il lavoro degli analisti della qualità per testare gli obiettivi del livello di servizio (SLO), come la correttezza, l'aggiornamento e le prestazioni dei dati in condizioni di carico di lavoro diverse.
I test end-to-end includono l'integrazione con origini dati e destinazioni nell'ambito dei test. Valuta come renderli disponibili nell'ambiente di preproduzione. Puoi archiviare i dati di test nell'ambiente di preproduzione stesso. Ad esempio, i dati di test vengono archiviati in un bucket Cloud Storage con i dati di input. In altri casi, i dati di test potrebbero provenire dall'esterno dell'ambiente di preproduzione, ad esempio da un argomento Pub/Sub tramite un abbonamento distinto nell'ambiente di produzione. Per le pipeline in streaming, puoi anche eseguire test end-to-end utilizzando i dati generati, ad esempio utilizzando il Generatore di dati in streaming di Dataflow per emulare le caratteristiche e i volumi dei dati di produzione.
Per le pipeline di streaming, utilizza l'ambiente di preproduzione per testare gli aggiornamenti della pipeline prima di apportare modifiche alla produzione. È importante testare e verificare le procedure di aggiornamento per le pipeline di streaming, in particolare se devi coordinare più passaggi, ad esempio quando esegui pipeline parallele per evitare tempi di riposo.
Ambiente di produzione
L'ambiente di produzione è un progetto Google Cloud dedicato. La distribuzione continua copia gli elementi di deployment nell'ambiente di produzione quando tutti i test end-to-end sono stati superati.
Best practice per lo sviluppo
Consulta le best practice per le pipeline Dataflow.
Testare la pipeline
Nello sviluppo software, i test di unità, i test di integrazione e i test end-to-end sono tipi comuni di test software. Questi tipi di test sono applicabili anche alle pipeline di dati.
L'SDK Apache Beam fornisce funzionalità per attivare questi test. Idealmente, ogni tipo di test ha come target un ambiente di implementazione diverso. Il seguente diagramma illustra come i test di unità, i test di integrazione e i test end-to-end vengono applicati a parti diverse della pipeline e dei dati.
Il diagramma mostra l'ambito dei diversi test e la loro relazione con le trasformazioni (sottoclassi DoFn e PTransform), le pipeline, le origini dati e gli sink di dati.
Le seguenti sezioni descrivono in che modo vari test software formali vengono applicati alle pipeline di dati che utilizzano Dataflow. Mentre leggi questa sezione, consulta nuovamente il diagramma per capire la relazione tra i diversi tipi di test.
Campionamento dei dati
Per osservare i dati in ogni passaggio di una pipeline Dataflow, attiva il campionamento dei dati durante il test. In questo modo, puoi visualizzare gli output delle trasformazioni per assicurarti che siano corretti.
Test delle unità
I test di unità valutano il corretto funzionamento delle sottoclassi DoFn e delle
trasformazioni composite
(sottoclassi PTransform) confrontando l'output di queste trasformazioni con un
insieme verificato di input e output di dati. In genere, gli sviluppatori possono eseguire questi
test nell'ambiente locale. I test possono essere eseguiti automaticamente anche tramite l'automazione dei test di unità utilizzando l'integrazione continua (CI) nell'ambiente di compilazione.
Direct Runner esegue i test di unità utilizzando un sottoinsieme più piccolo di dati di test di riferimento incentrati sul test della logica aziendale delle trasformazioni. I dati di test devono essere sufficientemente piccoli da poter essere inseriti nella memoria locale della macchina su cui viene eseguito il test.
L'SDK Apache Beam fornisce una regola JUnit chiamata
TestPipeline
per i test di unità delle singole trasformazioni (sottoclassi DoFn), delle trasformazioni composite
(sottoclassi PTransform) e di intere pipeline. Puoi utilizzare TestPipeline su un
eseguitore di pipeline Apache Beam come Direct Runner o Dataflow Runner per applicare asserzioni ai contenuti degli oggetti
PCollection utilizzando
PAssert, come mostrato nel seguente snippet di codice di una
classe di test JUnit:
@Rule
public final transient TestPipeline p = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void myPipelineTest() throws Exception {
final PCollection<String> pcol = p.apply(...)
PAssert.that(pcol).containsInAnyOrder(...);
p.run();
}
Test delle unità per le singole trasformazioni
Se suddividi il codice in trasformazioni riutilizzabili, ad esempio come classi nidificate statiche o di primo livello, puoi creare test mirati per parti diverse della pipeline. Oltre ai vantaggi dei test, le trasformazioni riutilizzabili migliorano la manutenibilità e la riutilizzabilità del codice incapsulando in modo naturale la logica aziendale della pipeline in componenti. Al contrario, il test delle singole parti della pipeline potrebbe essere difficile se la pipeline utilizza classi interne anonime per implementare le trasformazioni.
Il seguente snippet di Java mostra l'implementazione delle trasformazioni come classi interne anonime, che non consente facilmente il test.
PipelineOptions options = PipelineOptionsFactory.create();
Pipeline p = Pipeline.create(options)
PCollection<Integer> output =
p.apply("Read from text", TextIO.Read.from(...))
.apply("Split words", ParDo.of(new DoFn() {
// Untestable anonymous transform 1
}))
.apply("Generate anagrams", ParDo.of(new DoFn() {
// Untestable anonymous transform 2
}))
.apply("Count words", Count.perElement());
Confronta l'esempio precedente con quello seguente, in cui le classi interne anonime vengono sottoposte a refactoring in sottoclassi DoFn concrete con nome. Puoi creare singoli test di unità per ogni sottoclasse DoFn concreta che compone la pipeline end-to-end.
PipelineOptions options = PipelineOptionsFactory.create();
Pipeline p = Pipeline.create(options)
PCollection<Integer> output =
p.apply("Read from text", TextIO.Read.from(...))
.apply("Split words", ParDo.of(new SplitIntoWordsFn()))
.apply("Generate anagrams", ParDo.of(new GenerateAnagramsFn()))
.apply("Count words", Count.perElement());
Il test di ogni sottoclasse DoFn è simile al test di unità di una pipeline
in batch che contiene una singola trasformazione. Utilizza la trasformazione Create per creare un oggetto PCollection di dati di test e poi passalo all'oggetto DoFn. Utilizza PAssert per affermare che i contenuti dell'oggetto PCollection
sono corretti. Il seguente esempio di codice Java utilizza la classe PAssert per verificare la correttezza del formato di output.
@Rule
public final transient TestPipeline p = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void testGenerateAnagramsFn() {
// Create the test input
PCollection<String> words = p.apply(Create.of("friend"));
// Test a single DoFn using the test input
PCollection<String> anagrams =
words.apply("Generate anagrams", ParDo.of(new GenerateAnagramsFn()));
// Assert correct output from
PAssert.that(anagrams).containsInAnyOrder(
"finder", "friend", "redfin", "refind");
p.run();
}
Test di integrazione
I test di integrazione verificano il corretto funzionamento dell'intera pipeline. Prendi in considerazione i seguenti tipi di test di integrazione:
- Un test di integrazione delle trasformazioni che valuta la funzionalità integrata di tutte le singole trasformazioni che compongono la pipeline di dati. Considera i test di integrazione delle trasformazioni come un test di unità per l'intera pipeline, esclusa l'integrazione con origini dati e destinazioni esterne. L'SDK Apache Beam fornisce metodi per fornire dati di test alla pipeline di dati e per verificare i risultati dell'elaborazione. Direct Runner viene utilizzato per eseguire i test di integrazione dei trasformatori.
Un test di integrazione di sistema che valuta l'integrazione della pipeline di dati con origini dati e destinazioni in tempo reale. Affinché la pipeline possa comunicare con i sistemi esterni, devi configurare i test con le credenziali appropriate per accedere ai servizi esterni. Le pipeline di streaming vengono eseguite indefinitamente, quindi devi decidere quando e come interrompere la pipeline in esecuzione. Utilizzando il runner diretto per eseguire test di integrazione di sistema, puoi verificare rapidamente l'integrazione tra la pipeline e altri sistemi senza dover inviare un job Dataflow e attendere il completamento.
Progetta test di trasformazione e integrazione di sistema per fornire un rapido rilevamento dei difetti e feedback senza rallentare la produttività degli sviluppatori. Per i test che richiedono più tempo, ad esempio quelli eseguiti come job Dataflow, ti consigliamo di utilizzare un test end-to-end eseguito meno di frequente.
Pensa a una pipeline di dati come a una o più trasformazioni correlate. Puoi creare una trasformazione composita incapsulante per la pipeline e utilizzare TestPipeline per eseguire un test di integrazione dell'intera pipeline. A seconda che tu voglia testare la pipeline in modalità batch o in streaming, fornisci i dati di test utilizzando le trasformazioni Create o TestStream.
Utilizzare i dati di test per i test di integrazione
Nell'ambiente di produzione, la pipeline è probabilmente integrata con origini e destinazioni dati diverse. Tuttavia, per i test di unità e di integrazione della trasformazione, concentrati sulla verifica della logica di business del codice della pipeline fornendo input di test e verificando direttamente l'output. Oltre a semplificare i test, questo approccio consente di isolare i problemi specifici della pipeline da quelli che potrebbero essere causati da origini dati e sink.
Testare le pipeline batch
Per le pipeline batch, utilizza la trasformazione Create per creare un oggetto PCollection
degli input dei dati di test da una raccolta in memoria standard, ad esempio un
oggetto List Java. L'utilizzo della trasformazione Create è appropriato se i dati di test sono abbastanza piccoli da essere inclusi nel codice. Puoi quindi utilizzare PAssert sugli oggetti PCollection di output per determinare la correttezza del codice della pipeline.
Questo approccio è supportato da Direct Runner e da Dataflow Runner.
Il seguente snippet di codice Java mostra le asserzioni relative agli oggetti PCollection
di output di una trasformazione composita che include alcune o tutte le singole
trasformazioni che costituiscono una pipeline (WeatherStatsPipeline). L'approccio è simile ai test di unità delle singole trasformazioni in una pipeline.
private class WeatherStatsPipeline extends
PTransform<PCollection<Integer>, PCollection<WeatherSummary>> {
@Override
public PCollection<WeatherSummary> expand(PCollection<Integer> input) {
// Pipeline transforms …
}
}
@Rule
public final transient TestPipeline p = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void testWeatherPipeline() {
// Create test input consisting of temperature readings
PCollection<Integer> tempCelsius =
p.apply(Create.of(24, 22, 20, 22, 21, 21, 20));
// CalculateWeatherStats calculates the min, max, and average temperature
PCollection<WeatherSummary> result =
tempCelsius.apply("Calculate weather statistics", new WeatherStatsPipeline());
// Assert correct output from CalculateWeatherStats
PAssert.thatSingleton(result).isEqualTo(new WeatherSummary.Builder()
.withAverageTemp(21)
.withMaxTemp(24)
.withMinTemp(20)
.build());
p.run();
}
Per testare il comportamento delle finestre, puoi anche utilizzare la trasformazione Create per creare elementi con timestamp, come mostrato nello snippet di codice seguente:
private static final Duration WINDOW_DURATION = Duration.standardMinutes(3);
@Rule
public final transient TestPipeline p = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void testWindowedData() {
PCollection<String> input =
p.apply(
Create.timestamped(
TimestampedValue.of("a", new Instant(0L)),
TimestampedValue.of("a", new Instant(0L)),
TimestampedValue.of("b", new Instant(0L)),
TimestampedValue.of("c", new Instant(0L)),
TimestampedValue.of("c", new Instant(0L).plus(WINDOW_DURATION)))
.withCoder(StringUtf8Coder.of()));
PCollection<KV<String, Long>> windowedCount =
input
.apply(Window.into(FixedWindows.of(WINDOW_DURATION)))
.apply(Count.perElement());
PAssert.that(windowedCount)
.containsInAnyOrder(
// Output from first window
KV.of("a", 2L),
KV.of("b", 1L),
KV.of("c", 1L),
// Output from second window
KV.of("c", 1L));
p.run();
}
Testare le pipeline di streaming
Le pipeline di streaming contengono ipotesi che definiscono come gestire i dati illimitati. Spesso queste ipotesi riguardano l'attualità dei dati in condizioni reali e, di conseguenza, influiscono sulla correttezza a seconda che si dimostrino vere o false. I test di integrazione per le pipeline di streaming dovrebbero includere test che simulano la natura non deterministica dell'arrivo dei dati in streaming.
Per
abilitare questi test,
l'SDK Apache Beam fornisce la
classe
TestStream
per modellare gli effetti dei tempi degli elementi (dati in anticipo, in tempo o in ritardo) sui risultati della pipeline di dati. Utilizza questi test insieme alla classe
PAssert
per verificare i risultati previsti.
TestStream è supportato da Direct Runner e Dataflow Runner. Il seguente esempio di codice crea una trasformazione TestStream:
final Duration WINDOW_DURATION = Duration.standardMinutes(3);
@Rule
public final transient TestPipeline p = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void testDroppedLateData() {
TestStream<String> input = TestStream.create(StringUtf8Coder.of())
// Add elements arriving before the watermark
.addElements(
TimestampedValue.of("a", new Instant(0L)),
TimestampedValue.of("a", new Instant(0L)),
TimestampedValue.of("b", new Instant(0L)),
TimestampedValue.of("c", new Instant(0L).plus(Duration.standardMinutes(3))))
// Advance the watermark past the end of the window
.advanceWatermarkTo(new Instant(0L).plus(WINDOW_DURATION).plus(Duration.standardMinutes(1)))
// Add elements which will be dropped due to lateness
.addElements(
TimestampedValue.of("c", new Instant(0L)))
// Advance the watermark to infinity which will close all windows
.advanceWatermarkToInfinity();
PCollection<KV<String, Long>> windowedCount =
p.apply(input)
.apply(Window.into(FixedWindows.of(WINDOW_DURATION)))
.apply(Count.perElement());
PAssert.that(windowedCount)
.containsInAnyOrder(
// Output from first window
KV.of("a", 2L),
KV.of("b", 1L),
KV.of("c", 1L));
p.run();
}
Per saperne di più su TestStream, consulta
Testare le pipeline illimitate in Apache Beam.
Per ulteriori informazioni su come utilizzare l'SDK Apache Beam per i test di unità, consulta la documentazione di Apache Beam.
Utilizzare i servizi Google Cloud nei test di integrazione
Direct Runner può essere integrato con i servizi Google Cloud, pertanto i test ad hoc nell'ambiente locale e i test di integrazione di sistema possono utilizzare Pub/Sub, BigQuery e altri servizi in base alle esigenze. Quando utilizzi Direct Runner, la pipeline viene eseguita come account utente
che hai configurato utilizzando lo strumento a riga di comando
gcloud
o come account di servizio specificato utilizzando la variabile di ambiente
GOOGLE_APPLICATION_CREDENTIALS. Pertanto, prima di eseguire la pipeline, devi concedere a questo account autorizzazioni sufficienti per le risorse richieste. Per maggiori dettagli, vedi
Autorizzazioni e sicurezza di Dataflow.
Per test di integrazione completamente locali, puoi utilizzare emulatori locali per alcuni servizi Google Cloud. Gli emulatori locali sono disponibili per Pub/Sub e Bigtable.
Per i test di integrazione di sistema delle pipeline in streaming, puoi utilizzare il metodo
setBlockOnRun (definito nell'interfaccia DirectOptions) per fare in modo che Direct Runner esegua la pipeline in modo asincrono.
In caso contrario, l'esecuzione della pipeline blocca il processo principale chiamante (ad esempio uno script nella pipeline di compilazione) finché la pipeline non viene interrotta manualmente. Se esegui la pipeline in modo asincrono, puoi utilizzare l'istanza PipelineResult
ritornata per annullare l'esecuzione della pipeline, come mostrato nel seguente
codice di esempio:
public interface StreamingIntegrationTestOptions extends
DirectOptions, StreamingOptions, MyOtherPipelineOptions {
...
}
@Rule
public final transient TestPipeline p = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void testNonBlockingPipeline() {
StreamingIntegrationTestOptions options =
p.getOptions().as(StreamingIntegrationOptions.class);
options.setBlockOnRun(false); // Set non-blocking pipeline execution
options.setStreaming(true); // Set streaming mode
p.apply(...); // Apply pipeline transformations
PipelineResult result = p.run(); // Run the pipeline
// Generate input, verify output, etc
...
// Later on, cancel the pipeline using the previously returned
result.cancel();
}
Test end-to-end
I test end-to-end verificano il corretto funzionamento della pipeline end-to-end eseguendola su Dataflow Runner in condizioni che assomigliano molto alla produzione. I test verificano che la logica di business funzioni correttamente utilizzando DataflowRunner e testano se la pipeline funziona come previsto sotto carichi simili alla produzione. In genere, esegui i test end-to-end in un progetto Google Cloud dedicato designato come ambiente di preproduzione.
Per testare la pipeline su scale diverse, utilizza diversi tipi di test end-to-end, ad esempio:
- Esegui test end-to-end su piccola scala utilizzando una piccola proporzione (ad esempio l'1%) del set di dati di test per convalidare rapidamente la funzionalità della pipeline nell'ambiente di preproduzione.
- Esegui test end-to-end su larga scala utilizzando un set di dati di test completo per convalidare la funzionalità della pipeline in condizioni e volumi di dati simili alla produzione.
Per le pipeline di streaming, ti consigliamo di eseguire le pipeline di test in parallelo con la pipeline di produzione se possono utilizzare gli stessi dati. Questa procedura consente di confrontare i risultati e il comportamento operativo, ad esempio la scalabilità automatica e il rendimento.
I test end-to-end consentono di prevedere il grado di soddisfazione della pipeline per gli SLO di produzione. L'ambiente di pre-produzione testa la pipeline in condizioni simili alla produzione. Nei test end-to-end, le pipeline vengono eseguite utilizzando Dataflow Runner per elaborare set di dati di riferimento completi che corrispondono o sono molto simili ai set di dati in produzione.
Potrebbe non essere possibile generare dati sintetici per i test che simulano con precisione i dati reali. Per risolvere questo problema, un approccio è utilizzare estrazioni depurate dalle origini dati di produzione per creare set di dati di riferimento in cui tutti i dati sensibili vengono anonimizzati tramite trasformazioni appropriate. Per questo scopo, ti consigliamo di utilizzare Sensitive Data Protection. Sensitive Data Protection può rilevare i dati sensibili da una serie di tipi di contenuti e origini dati e applicare una serie di tecniche di anonimizzazione, tra cui oscuramento, mascheramento, crittografia con protezione del formato e spostamento della data.
Differenze nei test end-to-end per le pipeline batch e in streaming
Prima di eseguire un test end-to-end completo su un set di dati di test di grandi dimensioni, ti consigliamo di eseguire un test con una percentuale inferiore di dati di test (ad esempio l'1%) e di verificare il comportamento previsto in un periodo di tempo più breve. Come avviene con i test di integrazione che utilizzano Direct Runner, puoi utilizzare PAssert sugli oggetti PCollection quando esegui le pipeline con Dataflow Runner. Per ulteriori informazioni su PAssert, consulta la sezione Test di unità in questa pagina.
A seconda del caso d'uso, la verifica di output molto grandi provenienti da test end-to-end potrebbe essere impraticabile, costosa o comunque complessa. In questo caso, puoi verificare i campioni rappresentativi dal set di risultati di output. Ad esempio, puoi utilizzare BigQuery per campionare e confrontare le righe di output con un set di dati di riferimento dei risultati previsti.
Per le pipeline di streaming, la simulazione di condizioni di streaming realistiche con dati sintetici potrebbe essere complessa. Un modo comune per fornire dati in streaming per i test end-to-end è integrare i test con le origini dati di produzione. Se utilizzi Pub/Sub come origine dati, puoi attivare un stream di dati separato per i test end-to-end tramite sottoscrizioni aggiuntive agli argomenti esistenti. Puoi quindi confrontare i risultati di pipeline diverse che utilizzano gli stessi dati, il che è utile per verificare le pipeline candidate rispetto ad altre pipeline di preproduzione e produzione.
Il seguente diagramma mostra in che modo questo metodo consente di eseguire in parallelo una pipeline di produzione e una pipeline di test in diversi ambienti di deployment.
Nel diagramma, entrambe le pipeline leggono dallo stesso argomento Pub/Sub, ma utilizzano iscrizioni distinte. Questa configurazione consente alle due pipeline di elaborare gli stessi dati in modo indipendente e di confrontare i risultati. La pipeline di test utilizza un account di servizio separato dal progetto di produzione e, pertanto, evita di utilizzare la quota di sottoscrittori Pub/Sub per il progetto di produzione.
A differenza delle pipeline batch, le pipeline di streaming continuano a essere eseguite finché non vengono annullate esplicitamente. Nei test end-to-end, devi decidere se lasciare la pipeline in esecuzione, ad esempio fino all'esecuzione del prossimo test end-to-end, o annullarla in un punto che rappresenta il completamento del test in modo da poter esaminare i risultati.
Il tipo di dati di test utilizzati influisce su questa decisione. Ad esempio, se utilizzi un insieme delimitato di dati di test fornito alla pipeline di streaming, potresti annullare la pipeline al termine dell'elaborazione di tutti gli elementi. In alternativa, se utilizzi un'origine dati reale, come un argomento Pub/Sub esistente utilizzato in produzione, o se generi continuamente dati di test, ti consigliamo di mantenere in esecuzione le pipeline di test per un periodo di tempo più lungo. Quest'ultimo ti consente di confrontare il comportamento con l'ambiente di produzione o anche con altre pipeline di test.