AWS Glue esempi di utilizzo dell'SDK per Rust

I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con. AWS Glue

Nozioni di base: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.

Le azioni sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.

Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.

Nozioni di base

Ciao AWS Glue

L’esempio di codice seguente mostra come iniziare a utilizzare AWS Glue.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let mut list_jobs = glue.list_jobs().into_paginator().send();
        while let Some(list_jobs_output) = list_jobs.next().await {
            match list_jobs_output {
                Ok(list_jobs) => {
                    let names = list_jobs.job_names();
                    info!(?names, "Found these jobs")
                }
                Err(err) => return Err(GlueMvpError::from_glue_sdk(err)),
            }
        }

• Per i dettagli sull'API, consulta ListJobs la sezione AWS SDK for Rust API reference.

Nozioni di base

Informazioni di base

L’esempio di codice seguente mostra come:

• Crea un crawler che esegua la scansione di un bucket Amazon S3 pubblico e generi un database di metadati. CSV-formatted

• Elenca le informazioni su database e tabelle nel tuo. AWS Glue Data Catalog

• Crea un processo per estrarre i dati CSV dal bucket S3, trasformare i dati e caricare l' JSON-formatted output in un altro bucket S3.

• Elenca le informazioni sulle esecuzioni dei processi, visualizza i dati trasformati e pulisci le risorse.

Per ulteriori informazioni, consulta Tutorial: Guida introduttiva a Studio. AWS Glue

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

Crea ed esegui un crawler che esegua la scansione di un bucket pubblico Amazon Simple Storage Service (Amazon S3) e generi un database di metadati che descrive i dati trovati. CSV-formatted

        let create_crawler = glue
            .create_crawler()
            .name(self.crawler())
            .database_name(self.database())
            .role(self.iam_role.expose_secret())
            .targets(
                CrawlerTargets::builder()
                    .s3_targets(S3Target::builder().path(CRAWLER_TARGET).build())
                    .build(),
            )
            .send()
            .await;

        match create_crawler {
            Err(err) => {
                let glue_err: aws_sdk_glue::Error = err.into();
                match glue_err {
                    aws_sdk_glue::Error::AlreadyExistsException(_) => {
                        info!("Using existing crawler");
                        Ok(())
                    }
                    _ => Err(GlueMvpError::GlueSdk(glue_err)),
                }
            }
            Ok(_) => Ok(()),
        }?;

        let start_crawler = glue.start_crawler().name(self.crawler()).send().await;

        match start_crawler {
            Ok(_) => Ok(()),
            Err(err) => {
                let glue_err: aws_sdk_glue::Error = err.into();
                match glue_err {
                    aws_sdk_glue::Error::CrawlerRunningException(_) => Ok(()),
                    _ => Err(GlueMvpError::GlueSdk(glue_err)),
                }
            }
        }?;

Elenca le informazioni su database e tabelle nel tuo. AWS Glue Data Catalog

        let database = glue
            .get_database()
            .name(self.database())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?
            .to_owned();
        let database = database
            .database()
            .ok_or_else(|| GlueMvpError::Unknown("Could not find database".into()))?;

        let tables = glue
            .get_tables()
            .database_name(self.database())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        let tables = tables.table_list();

Crea ed esegui un job che estrae i dati CSV dal bucket Amazon S3 di origine, li trasforma rimuovendo e rinominando i campi e caricando l' JSON-formatted output in un altro bucket Amazon S3.

        let create_job = glue
            .create_job()
            .name(self.job())
            .role(self.iam_role.expose_secret())
            .command(
                JobCommand::builder()
                    .name("glueetl")
                    .python_version("3")
                    .script_location(format!("s3://{}/job.py", self.bucket()))
                    .build(),
            )
            .glue_version("3.0")
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        let job_name = create_job.name().ok_or_else(|| {
            GlueMvpError::Unknown("Did not get job name after creating job".into())
        })?;

        let job_run_output = glue
            .start_job_run()
            .job_name(self.job())
            .arguments("--input_database", self.database())
            .arguments(
                "--input_table",
                self.tables
                    .first()
                    .ok_or_else(|| GlueMvpError::Unknown("Missing crawler table".into()))?
                    .name(),
            )
            .arguments("--output_bucket_url", self.bucket())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        let job = job_run_output
            .job_run_id()
            .ok_or_else(|| GlueMvpError::Unknown("Missing run id from just started job".into()))?
            .to_string();

Eliminare tutte le risorse create dalla demo.

        glue.delete_job()
            .job_name(self.job())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        for t in &self.tables {
            glue.delete_table()
                .name(t.name())
                .database_name(self.database())
                .send()
                .await
                .map_err(GlueMvpError::from_glue_sdk)?;
        }

        glue.delete_database()
            .name(self.database())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        glue.delete_crawler()
            .name(self.crawler())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

• Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella documentazione di riferimento dell’API SDK AWS per Rust.

  • CreateCrawler

  • CreateJob

  • DeleteCrawler

  • DeleteDatabase

  • DeleteJob

  • DeleteTable

  • GetCrawler

  • GetDatabase

  • GetDatabases

  • GetJob

  • GetJobRun

  • GetJobRuns

  • GetTables

  • ListJobs

  • StartCrawler

  • StartJobRun

Azioni

CreateCrawler

L’esempio di codice seguente mostra come utilizzare CreateCrawler.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let create_crawler = glue
            .create_crawler()
            .name(self.crawler())
            .database_name(self.database())
            .role(self.iam_role.expose_secret())
            .targets(
                CrawlerTargets::builder()
                    .s3_targets(S3Target::builder().path(CRAWLER_TARGET).build())
                    .build(),
            )
            .send()
            .await;

        match create_crawler {
            Err(err) => {
                let glue_err: aws_sdk_glue::Error = err.into();
                match glue_err {
                    aws_sdk_glue::Error::AlreadyExistsException(_) => {
                        info!("Using existing crawler");
                        Ok(())
                    }
                    _ => Err(GlueMvpError::GlueSdk(glue_err)),
                }
            }
            Ok(_) => Ok(()),
        }?;

• Per i dettagli sull'API, consulta CreateCrawler la sezione AWS SDK for Rust API reference.

CreateJob

L’esempio di codice seguente mostra come utilizzare CreateJob.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let create_job = glue
            .create_job()
            .name(self.job())
            .role(self.iam_role.expose_secret())
            .command(
                JobCommand::builder()
                    .name("glueetl")
                    .python_version("3")
                    .script_location(format!("s3://{}/job.py", self.bucket()))
                    .build(),
            )
            .glue_version("3.0")
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        let job_name = create_job.name().ok_or_else(|| {
            GlueMvpError::Unknown("Did not get job name after creating job".into())
        })?;

• Per i dettagli sull'API, consulta CreateJob la sezione AWS SDK for Rust API reference.

DeleteCrawler

L’esempio di codice seguente mostra come utilizzare DeleteCrawler.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        glue.delete_crawler()
            .name(self.crawler())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

• Per i dettagli sull'API, consulta DeleteCrawler la sezione AWS SDK for Rust API reference.

DeleteDatabase

L’esempio di codice seguente mostra come utilizzare DeleteDatabase.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        glue.delete_database()
            .name(self.database())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

• Per i dettagli sull'API, consulta DeleteDatabase la sezione AWS SDK for Rust API reference.

DeleteJob

L’esempio di codice seguente mostra come utilizzare DeleteJob.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        glue.delete_job()
            .job_name(self.job())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

• Per i dettagli sull'API, consulta DeleteJob la sezione AWS SDK for Rust API reference.

DeleteTable

L’esempio di codice seguente mostra come utilizzare DeleteTable.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        for t in &self.tables {
            glue.delete_table()
                .name(t.name())
                .database_name(self.database())
                .send()
                .await
                .map_err(GlueMvpError::from_glue_sdk)?;
        }

• Per i dettagli sull'API, consulta DeleteTable la sezione AWS SDK for Rust API reference.

GetCrawler

L’esempio di codice seguente mostra come utilizzare GetCrawler.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

            let tmp_crawler = glue
                .get_crawler()
                .name(self.crawler())
                .send()
                .await
                .map_err(GlueMvpError::from_glue_sdk)?;

• Per i dettagli sull'API, consulta GetCrawler la sezione AWS SDK for Rust API reference.

GetDatabase

L’esempio di codice seguente mostra come utilizzare GetDatabase.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let database = glue
            .get_database()
            .name(self.database())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?
            .to_owned();
        let database = database
            .database()
            .ok_or_else(|| GlueMvpError::Unknown("Could not find database".into()))?;

• Per i dettagli sull'API, consulta GetDatabase la sezione AWS SDK for Rust API reference.

GetJobRun

L’esempio di codice seguente mostra come utilizzare GetJobRun.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let get_job_run = || async {
            Ok::<JobRun, GlueMvpError>(
                glue.get_job_run()
                    .job_name(self.job())
                    .run_id(job_run_id.to_string())
                    .send()
                    .await
                    .map_err(GlueMvpError::from_glue_sdk)?
                    .job_run()
                    .ok_or_else(|| GlueMvpError::Unknown("Failed to get job_run".into()))?
                    .to_owned(),
            )
        };

        let mut job_run = get_job_run().await?;
        let mut state = job_run.job_run_state().unwrap_or(&unknown_state).to_owned();

        while matches!(
            state,
            JobRunState::Starting | JobRunState::Stopping | JobRunState::Running
        ) {
            info!(?state, "Waiting for job to finish");
            tokio::time::sleep(self.wait_delay).await;

            job_run = get_job_run().await?;
            state = job_run.job_run_state().unwrap_or(&unknown_state).to_owned();
        }

• Per i dettagli sull'API, consulta GetJobRun la sezione AWS SDK for Rust API reference.

GetTables

L’esempio di codice seguente mostra come utilizzare GetTables.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let tables = glue
            .get_tables()
            .database_name(self.database())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        let tables = tables.table_list();

• Per i dettagli sull'API, consulta GetTables la sezione AWS SDK for Rust API reference.

ListJobs

L’esempio di codice seguente mostra come utilizzare ListJobs.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let mut list_jobs = glue.list_jobs().into_paginator().send();
        while let Some(list_jobs_output) = list_jobs.next().await {
            match list_jobs_output {
                Ok(list_jobs) => {
                    let names = list_jobs.job_names();
                    info!(?names, "Found these jobs")
                }
                Err(err) => return Err(GlueMvpError::from_glue_sdk(err)),
            }
        }

• Per i dettagli sull'API, consulta ListJobs la sezione AWS SDK for Rust API reference.

StartCrawler

L’esempio di codice seguente mostra come utilizzare StartCrawler.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let start_crawler = glue.start_crawler().name(self.crawler()).send().await;

        match start_crawler {
            Ok(_) => Ok(()),
            Err(err) => {
                let glue_err: aws_sdk_glue::Error = err.into();
                match glue_err {
                    aws_sdk_glue::Error::CrawlerRunningException(_) => Ok(()),
                    _ => Err(GlueMvpError::GlueSdk(glue_err)),
                }
            }
        }?;

• Per i dettagli sull'API, consulta StartCrawler la sezione AWS SDK for Rust API reference.

StartJobRun

L’esempio di codice seguente mostra come utilizzare StartJobRun.

SDK per Rust

Nota

C'è altro su. GitHub Trova l’esempio completo e scopri di più sulla configurazione e l’esecuzione nel repository di esempi di codice AWS.

        let job_run_output = glue
            .start_job_run()
            .job_name(self.job())
            .arguments("--input_database", self.database())
            .arguments(
                "--input_table",
                self.tables
                    .first()
                    .ok_or_else(|| GlueMvpError::Unknown("Missing crawler table".into()))?
                    .name(),
            )
            .arguments("--output_bucket_url", self.bucket())
            .send()
            .await
            .map_err(GlueMvpError::from_glue_sdk)?;

        let job = job_run_output
            .job_run_id()
            .ok_or_else(|| GlueMvpError::Unknown("Missing run id from just started job".into()))?
            .to_string();

• Per i dettagli sull'API, consulta StartJobRun la sezione AWS SDK for Rust API reference.