Forenkle og få fart på Apache Spark-applikasjoner på Amazon Redshift-data med Amazon Redshift-integrasjon for Apache Spark

Publisert av Platon

Følgere: 0

Kundene bruker Amazon RedShift å kjøre sine forretningskritiske analyser på petabyte med strukturerte og semistrukturerte data. Apache Spark er et populært rammeverk som du kan bruke til å bygge applikasjoner for brukstilfeller som ETL (ekstrahere, transformere og laste), interaktiv analyse og maskinlæring (ML). Apache Spark lar deg bygge applikasjoner på en rekke språk, som Java, Scala og Python, ved å få tilgang til dataene i ditt Amazon Redshift-datavarehus.

Amazon Redshift-integrasjon for Apache Spark hjelper utviklere sømløst å bygge og kjøre Apache Spark-applikasjoner på Amazon Redshift-data. Utviklere kan bruke AWS-analyse og ML-tjenester som f.eks Amazon EMR, AWS Limog Amazon SageMaker å enkelt bygge Apache Spark-applikasjoner som leser fra og skriver til Amazon Redshift-datavarehuset deres. Du kan gjøre det uten å gå på akkord med ytelsen til applikasjonene dine eller transaksjonskonsistensen til dataene dine.

I dette innlegget diskuterer vi hvorfor Amazon Redshift-integrasjon for Apache Spark er kritisk og effektiv for analyser og ML. I tillegg diskuterer vi brukstilfeller som bruker Amazon Redshift-integrasjon med Apache Spark for å øke virksomhetens effekt. Til slutt leder vi deg gjennom trinnvise eksempler på hvordan du bruker denne offisielle AWS-koblingen i en Apache Spark-applikasjon.

Amazon Redshift-integrasjon for Apache Spark

Amazon Redshift-integrasjonen for Apache Spark minimerer den tungvinte og ofte manuelle prosessen med å sette opp en gnist-rødforskyvningskobling (fellesskapsversjon) og forkorter tiden som trengs for å forberede seg til analyse- og ML-oppgaver. Du trenger bare å spesifisere tilkoblingen til datavarehuset ditt, og du kan begynne å jobbe med Amazon Redshift-data fra dine Apache Spark-baserte applikasjoner i løpet av minutter.

Du kan bruke flere pushdown-funksjoner for operasjoner som sorterings-, aggregerings-, limit-, join- og skalarfunksjoner, slik at bare de relevante dataene flyttes fra Amazon Redshift-datavarehuset til den konsumerende Apache Spark-applikasjonen. Dette lar deg forbedre ytelsen til applikasjonene dine. Amazon Redshift-administratorer kan enkelt identifisere SQL generert fra Spark-baserte applikasjoner. I dette innlegget viser vi hvordan du kan finne ut SQL generert av Apache Spark-jobben.

Dessuten bruker Amazon Redshift-integrasjon for Apache Spark Parquet-filformat når dataene iscenesettes i en midlertidig katalog. Amazon Redshift bruker UNLOAD SQL-setningen til å lagre disse midlertidige dataene Amazon enkel lagringstjeneste (Amazon S3). Apache Spark-applikasjonen henter resultatene fra den midlertidige katalogen (lagret i Parquet-filformat), noe som forbedrer ytelsen.

Du kan også bidra til å gjøre applikasjonene dine sikrere ved å bruke AWS identitets- og tilgangsadministrasjon (IAM)-legitimasjon for å koble til Amazon Redshift.

Amazon Redshift-integrasjon for Apache Spark er bygget på toppen av gnist-rødforskyvningskontakten (fellesskapsversjon) og forbedrer den for ytelse og sikkerhet, og hjelper deg å få opptil 10 ganger raskere applikasjonsytelse.

Bruk tilfeller for Amazon Redshift-integrasjon med Apache Spark

For vårt bruksområde ønsker ledelsen i det produktbaserte selskapet å vite salget for hvert produkt på tvers av flere markeder. Ettersom salget for selskapet svinger dynamisk, har det blitt en utfordring for ledelsen å spore salget på tvers av flere markeder. Imidlertid synker det samlede salget, og selskapets ledelse ønsker å finne ut hvilke markeder som ikke gir resultater, slik at de kan målrette disse markedene for promoteringskampanjer.

For salg på tvers av flere markeder er produktsalgsdata som bestillinger, transaksjoner og forsendelsesdata tilgjengelig på Amazon S3 i datasjøen. Dataingeniørteamet kan bruke Apache Spark med Amazon EMR eller AWS Glue for å analysere disse dataene i Amazon S3.

Lagerdataene er tilgjengelige i Amazon Redshift. På samme måte kan dataingeniørteamet analysere disse dataene med Apache Spark ved å bruke Amazon EMR eller en AWS Glue-jobb ved å bruke Amazon Redshift-integrasjonen for Apache Spark for å utføre aggregeringer og transformasjoner. Det aggregerte og transformerte datasettet kan lagres tilbake i Amazon Redshift ved å bruke Amazon Redshift-integrasjonen for Apache Spark.

Å bruke et distribuert rammeverk som Apache Spark med Amazon Redshift-integrasjonen for Apache Spark kan gi synlighet over datainnsjøen og datavarehuset for å generere salgsinnsikt. Denne innsikten kan gjøres tilgjengelig for forretningsinteressenter og forretningsbrukere i Amazon Redshift for å ta informerte beslutninger om å kjøre målrettede kampanjer for lavinntektsmarkedssegmentene.

I tillegg kan vi bruke Amazon Redshift-integrasjonen med Apache Spark i følgende brukstilfeller:

En Amazon EMR- eller AWS Glue-kunde som kjører Apache Spark-jobber ønsker å transformere data og skrive det inn i Amazon Redshift som en del av deres ETL-pipeline
En ML-kunde bruker Apache Spark med SageMaker for funksjonsutvikling for å få tilgang til og transformere data i Amazon Redshift
En Amazon EMR-, AWS Glue- eller SageMaker-kunde bruker Apache Spark for interaktiv dataanalyse med data på Amazon Redshift fra bærbare datamaskiner

Eksempler på Amazon Redshift-integrasjon for Apache Spark i en Apache Spark-applikasjon

I dette innlegget viser vi trinnene for å koble Amazon Redshift fra Amazon EMR på Amazon Elastic Compute Cloud (Amazon EC2), Amazon EMR-serverløs, og AWS Lim ved hjelp av et vanlig skript. I den følgende eksempelkoden genererer vi en rapport som viser det kvartalsvise salget for år 2008. For å gjøre det slår vi sammen to Amazon Redshift-tabeller ved å bruke en Apache Spark DataFrame, kjører en predikat-pushdown, samler og sorterer dataene, og skriver de transformerte data tilbake til Amazon Redshift. Skriptet bruker PySpark

Manuset bruker IAM-basert autentisering for Amazon Redshift. IAM-roller brukt av Amazon EMR og AWS Glue bør ha de nødvendige tillatelsene til å autentisere Amazon Redshift, og tilgang til en S3-bøtte for midlertidig datalagring.

Følgende eksempelpolicy lar IAM-rollen kalle GetClusterCredentials operasjoner:

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "redshift:GetClusterCredentials", "Resource": "arn:aws:redshift:<aws_region_name>:xxxxxxxxxxxx:dbuser:*/temp_*" }
}

Følgende eksempelpolicy gir tilgang til en S3-bøtte for midlertidig datalagring:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": "arn:aws:s3:::<s3_bucket_name>" } ]
}

Det komplette manuset er som følger:

from pyspark.sql import SparkSession
from pyspark.sql.functions import col # Initiate Apache Spark session
spark = SparkSession .builder .appName("SparkRedshiftConnector") .enableHiveSupport() .getOrCreate() # Set connection options for Amazon Redshift
jdbc_iam_url = "jdbc:redshift:iam://redshift-spark-connector-1.xxxxxxxxxxx.<aws_region_name>.redshift.amazonaws.com:5439/sample_data_dev"
temp_dir = 's3://<s3_bucket_name>/redshift-temp-dir/'
aws_role = 'arn:aws:iam::xxxxxxxxxxxx:role/redshift-s3' # Set query group for the query. More details on Amazon Redshift WLM https://docs.aws.amazon.com/redshift/latest/dg/cm-c-executing-queries.html
queryGroup = "emr-redshift"
jdbc_iam_url_withQueryGroup = jdbc_iam_url+'?queryGroup='+queryGroup # Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url_withQueryGroup+';user='+userName # Define the Amazon Redshift context
redshiftOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Create the sales DataFrame from Amazon Redshift table using io.github.spark_redshift_community.spark.redshift class
sales_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.sales") .load()
) # Create the date Data Frame from Amazon Redshift table
date_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.date") .load()
) # Assign a Data Frame to the above output which will be written back to Amazon Redshift
output_df= sales_df.join(date_df, sales_df.dateid == date_df.dateid, 'inner').where( col("year") == 2008).groupBy("qtr").sum("qtysold").select( col("qtr"), col("sum(qtysold)")).sort(["qtr"], ascending=[1]).withColumnRenamed("sum(qtysold)","total_quantity_sold") # Display the output
output_df.show() ## Lets drop the queryGroup for easy validation of push down queries
# Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url+'?user='+userName # Define the Amazon Redshift context
redshiftWriteOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Write the Data Frame back to Amazon Redshift
output_df.write .format("io.github.spark_redshift_community.spark.redshift") .mode("overwrite") .options(**redshiftWriteOptions) .option("dbtable", "tickit.test") .save()

Hvis du planlegger å bruke det foregående skriptet i miljøet ditt, må du passe på at du erstatter verdiene for følgende variabler med de riktige verdiene for miljøet ditt: jdbc_iam_url, temp_dirog aws_role.

I neste avsnitt går vi gjennom trinnene for å kjøre dette skriptet for å samle et eksempeldatasett som er gjort tilgjengelig i Amazon Redshift.

Forutsetninger

Før vi begynner, sørg for at følgende forutsetninger er oppfylt:

Distribuer ressurser ved hjelp av AWS CloudFormation

Fullfør følgende trinn for å distribuere CloudFormation-stakken:

Logg deg på AWS-administrasjonskonsoll, start deretter CloudFormation-stakken:

Du kan også last ned CloudFormation-malen å opprette ressursene nevnt i dette innlegget gjennom infrastruktur som kode (IaC). Bruk denne malen når du lanserer en ny CloudFormation-stabel.

Rull ned til bunnen av siden for å velge Jeg erkjenner at AWS CloudFormation kan skape IAM-ressurser etter Ekspertiser, velg deretter Lag stabel.

Stabelopprettingsprosessen tar 15–20 minutter å fullføre. CloudFormation-malen oppretter følgende ressurser:

- En Amazon VPC med nødvendige undernett, rutetabeller og NAT-gateway
- En S3 bøtte med navnet redshift-spark-databucket-xxxxxxx (merk at xxxxxxx er en tilfeldig streng for å gjøre bøttenavnet unikt)
- En Amazon Redshift-klynge med eksempeldata lastet inn i databasen dev og den primære brukeren redshiftmasteruser. For formålet med dette blogginnlegget, redshiftmasteruser med administrative tillatelser brukes. Det anbefales imidlertid å bruke en bruker med finmasket tilgangskontroll i produksjonsmiljø.
- En IAM-rolle som skal brukes for Amazon Redshift med muligheten til å be om midlertidig legitimasjon fra Amazon Redshift-klyngens utviklingsdatabase
- Amazon EMR Studio med de nødvendige IAM-rollene
- Amazon EMR utgivelsesversjon 6.9.0 på en EC2-klynge med de nødvendige IAM-rollene
- En Amazon EMR Serverless-applikasjonsutgivelse versjon 6.9.0
- En AWS Glue-tilkobling og AWS Glue-jobb versjon 4.0
- A Jupyter notisbok å kjøre med Amazon EMR Studio ved å bruke Amazon EMR på en EC2-klynge
- Et PySpark-skript for å kjøre med Amazon EMR Studio og Amazon EMR Serverless

Etter at stabelen er opprettet, velger du stabelnavnet redshift-spark og naviger til Utganger

Vi bruker disse utgangsverdiene senere i dette innlegget.

I de neste delene viser vi trinnene for Amazon Redshift-integrasjon for Apache Spark fra Amazon EMR på Amazon EC2, Amazon EMR Serverless og AWS Glue.

Bruk Amazon Redshift-integrasjon med Apache Spark på Amazon EMR på EC2

Fra og med Amazon EMR-versjon 6.9.0 og nyere, er koblingen som bruker Amazon Redshift-integrasjon for Apache Spark og Amazon Redshift JDBC-driver tilgjengelig lokalt på Amazon EMR. Disse filene er plassert under /usr/share/aws/redshift/ katalog. Imidlertid, i de tidligere versjonene av Amazon EMR samfunnet versjon av spark-redshift kontakt er tilgjengelig.

Følgende eksempel viser hvordan du kobler Amazon Redshift ved hjelp av en PySpark-kjerne via en Amazon EMR Studio notisbok. CloudFormation-stakken opprettet Amazon EMR Studio, Amazon EMR på en EC2-klynge og en Jupyter-notisbok tilgjengelig for kjøring. For å gå gjennom dette eksemplet, fullfør følgende trinn:

Last ned Jupyter-notisboken som er tilgjengelig i S3-bøtten for deg:
- I CloudFormation-stabelutgangene, se etter verdien for EMRStudioNotebook, som skal peke på redshift-spark-emr.ipynb notatbok tilgjengelig i S3-bøtten.
- Velg koblingen eller åpne koblingen i en ny fane ved å kopiere URL-en til notatboken.
- Etter at du har åpnet koblingen, last ned notatboken ved å velge Last ned, som vil lagre filen lokalt på datamaskinen din.

Få tilgang til Amazon EMR Studio ved å velge eller kopiere lenken som er gitt i CloudFormation-stabelutgangene for nøkkelen EMRStudioURL.
Velg i navigasjonsruten arbeidsområder.
Velg Opprett arbeidsområde.
Oppgi et navn for arbeidsområdet, for eksempel redshift-spark.
Utvid Avansert konfigurasjon delen og velg Koble Workspace til en EMR-klynge.
Under Fest til en EMR-klynge, velg EMR-klyngen med navnet emrCluster-Redshift-Spark.
Velg Opprett arbeidsområde.
Etter at Amazon EMR Studio-arbeidsområdet er opprettet og i Vedlagt-status, kan du få tilgang til arbeidsområdet ved å velge navnet på arbeidsområdet.

Dette bør åpne arbeidsområdet i en ny fane. Merk at hvis du har en popup-blokkering, må du kanskje la arbeidsområdet åpne eller deaktivere popup-blokkering.

I Amazon EMR Studio Workspace laster vi nå opp Jupyter-notisboken vi lastet ned tidligere.

Velg Last opp for å bla gjennom ditt lokale filsystem og laste opp Jupyter-notisboken (redshift-spark-emr.ipynb).
Velg (dobbeltklikk) på redshift-spark-emr.ipynb notatbok i arbeidsområdet for å åpne notatboken.

Den bærbare datamaskinen inneholder detaljene om forskjellige oppgaver som den utfører. Merk at i avsnittet Definer variablene som skal kobles til Amazon Redshift-klyngen, trenger du ikke å oppdatere verdiene for jdbc_iam_url, temp_dirog aws_role fordi disse er oppdatert for deg av AWS CloudFormation. AWS CloudFormation har også utført trinnene nevnt i Forutsetninger delen av notatboken.

Du kan nå begynne å kjøre den bærbare datamaskinen.

Kjør de individuelle cellene ved å velge dem og deretter velge Spille.

Du kan også bruke tastekombinasjonen av Shift + Enter or Shift+Retur. Alternativt kan du kjøre alle cellene ved å velge Kjør alle celler på Kjør menyen.

Finn predikat-pushdown-operasjonen utført på Amazon Redshift-klyngen av Amazon Redshift-integrasjonen for Apache Spark.

Vi kan også se de midlertidige dataene som er lagret på Amazon S3 i det optimaliserte Parkett-formatet. Utgangen kan sees fra å kjøre cellen i seksjonen Få den siste spørringen utført på Amazon Redshift.

For å validere tabellen opprettet av jobben fra Amazon EMR på Amazon EC2, naviger til Amazon Redshift-konsollen og velg klyngen redshift-spark-redshift-cluster på Kontrollpanel for klargjorte klynger side.
I klyngedetaljene, på Spørr data meny, velg Spørring i spørringsredigering v2.
Velg klyngen i navigasjonsruten og koble til Amazon Redshift-klyngen når den ber om autentisering.
Plukke ut Midlertidig legitimasjon.
Til Database, Tast inn dev.
Til brukernavn, Tast inn redshiftmasteruser.
Velg Spar.
Utvid klyngen i navigasjonsruten redshift-spark-redshift-cluster, utvide utviklerdatabasen, utvide tickit, og utvide tabeller for å liste opp alle tabellene i skjemaet tickit.

Du bør finne bordet test_emr.

Velg (høyreklikk) tabellen test_emr, velg deretter Velg bord for å spørre i tabellen.
Velg Kjør for å kjøre SQL-setningen.

Bruk Amazon Redshift-integrasjon med Apache Spark på Amazon EMR Serverless

Amazon EMR-utgivelsesversjon 6.9.0 og nyere gir Amazon Redshift-integrasjon for Apache Spark JAR-er (administrert av Amazon Redshift) og Amazon Redshift JDBC JAR-er lokalt på Amazon EMR Serverless også. Disse filene er plassert under /usr/share/aws/redshift/ katalog. I det følgende eksempelet bruker vi Python-skriptet som er gjort tilgjengelig i S3-bøtten av CloudFormation-stakken vi opprettet tidligere.

I CloudFormation-stabelutgangene noterer du verdien for EMRServerlessExecutionScript, som er plasseringen av Python-skriptet i S3-bøtten.
Merk også verdien for EMRServerlessJobExecutionRole, som er IAM-rollen som skal brukes til å kjøre Amazon EMR Serverless-jobben.
Få tilgang til Amazon EMR Studio ved å velge eller kopiere lenken som er gitt i CloudFormation-stabelutgangene for nøkkelen EMRStudioURL.
Velg applikasjoner etter server~~POS=TRUNC i navigasjonsruten.

Du vil finne en EMR-applikasjon opprettet av CloudFormation-stakken med navnet emr-spark-redshift.

Velg søknadsnavnet for å sende inn en jobb.
Velg Send inn jobb.
Under JobbdetaljerFor Navn, skriv inn et identifiserbart navn for jobben.
Til Runtime rolle, velg IAM-rollen du noterte fra CloudFormation-stabelutgangen tidligere.
Til Skriptplassering, oppgi banen til Python-skriptet du noterte tidligere fra CloudFormation-stabelutgangen.
Utvid delen Spark egenskaper og velg Rediger i tekst

Skriv inn følgende verdi i tekstboksen, som gir banen til redshift-connector, Amazon Redshift JDBC-driver, spark-avro JAR, og minimal-json JAR filer:

--jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar

Velg Send inn jobb.
Vent til jobben er fullført og kjørestatusen vises som Suksess.
Naviger til Amazon Redshift-spørringsredigering for å se om tabellen ble opprettet.
Sjekk pushdown-spørringene som kjøres for Amazon Redshift-spørringsgruppen emr-serverless-redshift. Du kan kjøre følgende SQL-setning mot databasen dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'emr-serverless-redshift' ORDER BY start_time DESC LIMIT 1
```

Du kan se at pushdown-spørringen og returresultatene er lagret i Parquet-filformat på Amazon S3.

Bruk Amazon Redshift-integrasjon med Apache Spark på AWS Glue

Fra og med AWS Glue versjon 4.0 og nyere, kan Apache Spark-jobbene som kobles til Amazon Redshift bruke Amazon Redshift-integrasjonen for Apache Spark og Amazon Redshift JDBC-driveren. Eksisterende AWS Glue-jobber som allerede bruker Amazon Redshift som kilde eller mål, kan oppgraderes til AWS Glue 4.0 for å dra nytte av denne nye koblingen. CloudFormation-malen som følger med dette innlegget oppretter følgende AWS Glue-ressurser:

AWS limtilkobling for Amazon Redshift – Forbindelsen for å etablere forbindelse fra AWS Glue til Amazon Redshift ved å bruke Amazon Redshift-integrasjonen for Apache Spark
IAM-rolle knyttet til AWS Glue-jobben – IAM-rollen for å administrere tillatelser for å kjøre AWS Glue-jobben
AWS limjobb – Skriptet for AWS Glue-jobben som utfører transformasjoner og aggregeringer ved å bruke Amazon Redshift-integrasjonen for Apache Spark

Følgende eksempel bruker AWS Glue-tilkoblingen knyttet til AWS Glue-jobben med PySpark og inkluderer følgende trinn:

Velg på AWS Lim-konsollen Tilkoblinger i navigasjonsruten.
Under Tilkoblinger, velg AWS Glue-tilkoblingen for Amazon Redshift opprettet av CloudFormation-malen.
Bekreft tilkoblingsdetaljene.

Du kan nå gjenbruke denne tilkoblingen i en jobb eller på tvers av flere jobber.

På Kontakter siden, velg AWS Glue-jobben opprettet av CloudFormation-stakken under Dine jobber, eller få tilgang til AWS Glue-jobben ved å bruke URL-en som er oppgitt for nøkkelen GlueJob i CloudFormation-stabelutgangen.
Få tilgang til og bekreft skriptet for AWS Glue-jobben.
På Jobbdetaljer fanen, sørg for at Lim versjon er satt til Lim 4.0.

Dette sikrer at jobben bruker det siste redshift-spark kontakten.

Expand Avanserte egenskaper og i Tilkoblinger seksjonen, kontroller at tilkoblingen opprettet av CloudFormation-stakken er vedlagt.
Bekreft jobbparameterne som er lagt til for AWS Lim-jobben. Disse verdiene er også tilgjengelige i utdataene for CloudFormation-stakken.
Velg Spar og deretter Kjør.

Du kan se statusen for jobben som kjøres på Kjør fanen.

Etter at jobbkjøringen er fullført, kan du verifisere utdataene fra tabelltestlimet som er opprettet av AWS Glue-jobben.
Vi sjekker pushdown-spørringene som kjøres for Amazon Redshift-spørringsgruppen glue-redshift. Du kan kjøre følgende SQL-setning mot databasen dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Beste praksis

Husk følgende beste fremgangsmåter:

Vurder å bruke Amazon Redshift-integrasjonen for Apache Spark fra Amazon EMR i stedet for å bruke redshift-spark kobling (fellesskapsversjon) for dine nye Apache Spark-jobber.
Hvis du har eksisterende Apache Spark-jobber ved å bruke redshift-spark kobling (fellesskapsversjon), vurder å oppgradere dem til å bruke Amazon Redshift-integrasjonen for Apache Spark
Amazon Redshift-integrasjonen for Apache Spark bruker automatisk predikat- og spørrings-pushdown for å optimalisere for ytelse. Vi anbefaler å bruke støttede funksjoner (autopushdown) i søket ditt. Amazon Redshift-integrasjonen for Apache Spark vil gjøre funksjonen om til en SQL-spørring og kjøre spørringen i Amazon Redshift. Denne optimaliseringen resulterer i at nødvendige data hentes, slik at Apache Spark kan behandle mindre data og ha bedre ytelse.
- Vurder å bruke samlede pushdown-funksjoner som avg, count, max, minog sum for å hente filtrerte data for databehandling.
- Vurder å bruke boolske pushdown-operatorer som in, isnull, isnotnull, contains, endswithog startswith for å hente filtrerte data for databehandling.
- Vurder å bruke logiske pushdown-operatører som and, orog not (eller !) for å hente filtrerte data for databehandling.
Det anbefales å bestå en IAM-rolle ved å bruke parameteren aws_iam_role for Amazon Redshift-autentisering fra Apache Spark-applikasjonen på Amazon EMR eller AWS Glue. IAM-rollen bør ha nødvendige tillatelser for å hente midlertidig IAM-legitimasjon for å autentisere til Amazon Redshift som vist i denne bloggens "Eksempler på Amazon Redshift-integrasjon for Apache Spark i en Apache Spark-applikasjon".
Med denne funksjonen trenger du ikke å vedlikeholde Amazon Redshift-brukernavnet og passordet ditt i Secrets Manager og Amazon Redshift-databasen.
Amazon Redshift bruker UNLOAD SQL-setningen til å lagre disse midlertidige dataene på Amazon S3. Apache Spark-applikasjonen henter resultatene fra den midlertidige katalogen (lagret i Parquet-filformat). Denne midlertidige katalogen på Amazon S3 ryddes ikke opp automatisk, og kan derfor legge til ekstra kostnader. Vi anbefaler å bruke Amazon S3 livssykluspolicyer for å definere oppbevaringsreglene for S3-bøtten.
Det anbefales å slå på Amazon Redshift revisjonslogging for å logge informasjonen om tilkoblinger og brukeraktiviteter i databasen din.
Det anbefales å slå på Amazon Redshift-kryptering i hvile å kryptere dataene dine slik Amazon Redshift skriver dem i sine datasentre og dekryptere dem for deg når du får tilgang til dem.
Det anbefales å oppgradere til AWS Glue v4.0 og nyere for å bruke Amazon Redshift-integrasjonen for Apache Spark, som er tilgjengelig ut av esken. Oppgradering til denne versjonen av AWS Glue vil automatisk gjøre bruk av denne funksjonen.
Det anbefales å oppgradere til Amazon EMR v6.9.0 og nyere for å bruke Amazon Redshift-integrasjonen for Apache Spark. Du trenger ikke å administrere noen drivere eller JAR-filer eksplisitt.
Vurder å bruke Amazon EMR Studio-notatbøker for å samhandle med Amazon Redshift-dataene dine i Apache Spark-applikasjonen.
Vurder å bruke AWS Glue Studio for å lage Apache Spark-jobber ved hjelp av et visuelt grensesnitt. Du kan også bytte til å skrive Apache Spark-kode i enten Scala eller PySpark i AWS Glue Studio.

Rydd opp

Fullfør følgende trinn for å rydde opp i ressursene som er opprettet som en del av CloudFormation-malen for å sikre at du ikke blir fakturert for ressursene hvis du ikke lenger skal bruke dem:

Stopp Amazon EMR Serverless-applikasjonen:
- Få tilgang til Amazon EMR Studio ved å velge eller kopiere lenken som er gitt i CloudFormation-stabelutgangene for nøkkelen EMRStudioURL.
- Velg applikasjoner etter server~~POS=TRUNC i navigasjonsruten.

Du vil finne en EMR-applikasjon opprettet av CloudFormation-stakken med navnet emr-spark-redshift.

- Hvis programstatusen vises som Stoppet, kan du gå videre til neste trinn. Men hvis applikasjonsstatusen er Startet, velg applikasjonsnavnet og velg deretter Stopp søknaden og Stopp søknaden igjen for å bekrefte.

Slett Amazon EMR Studio Workspace:
- Få tilgang til Amazon EMR Studio ved å velge eller kopiere lenken som er gitt i CloudFormation-stabelutgangene for nøkkelen EMRStudioURL.
- Velg arbeidsområder i navigasjonsruten.
- Velg arbeidsområdet du opprettet og velg Delete, velg deretter Delete igjen for å bekrefte.
Slett CloudFormation-stabelen:

- På AWS CloudFormation-konsollen, naviger til stabelen du opprettet tidligere.
- Velg stabelnavnet og velg deretter Delete for å fjerne stabelen og slette ressursene som er opprettet som en del av dette innlegget.
- Velg på bekreftelsesskjermen Slett stabel.

konklusjonen

I dette innlegget forklarte vi hvordan du kan bruke Amazon Redshift-integrasjonen for Apache Spark til å bygge og distribuere applikasjoner med Amazon EMR på Amazon EC2, Amazon EMR Serverless og AWS Glue for automatisk å bruke predikat- og spørrings-pushdown for å optimalisere spørringsytelsen for data i Amazon Redshift. Det anbefales sterkt å bruke Amazon Redshift-integrasjon for Apache Spark for sømløs og sikker tilkobling til Amazon Redshift fra Amazon EMR eller AWS Glue.

Her er hva noen av kundene våre har å si om Amazon Redshift-integrasjonen for Apache Spark:

"Vi gir ingeniørene våre mulighet til å bygge datapipelines og applikasjoner med Apache Spark ved å bruke Python og Scala. Vi ønsket en skreddersydd løsning som forenklet driften og leverte raskere og mer effektivt for våre kunder, og det er det vi får med den nye Amazon Redshift-integrasjonen for Apache Spark.»

—Huron Consulting

"GE Aerospace bruker AWS-analyse og Amazon Redshift for å muliggjøre kritisk forretningsinnsikt som driver viktige forretningsbeslutninger. Med støtte for autokopiering fra Amazon S3 kan vi bygge enklere datapipelines for å flytte data fra Amazon S3 til Amazon Redshift. Dette akselererer dataproduktteamenes evne til å få tilgang til data og levere innsikt til sluttbrukere. Vi bruker mer tid på å tilføre verdi gjennom data og mindre tid på integrasjoner.»

— GE Aerospace

"Vårt fokus er å gi selvbetjent tilgang til data for alle våre brukere hos Goldman Sachs. Gjennom Legend, vår åpen kildekode-plattform for dataadministrasjon og -styring, lar vi brukere utvikle datasentriske applikasjoner og utlede datadrevet innsikt mens vi samarbeider på tvers av finansnæringen. Med Amazon Redshift-integrasjonen for Apache Spark, vil dataplattformteamet vårt kunne få tilgang til Amazon Redshift-data med minimale manuelle trinn, noe som muliggjør nullkode ETL som vil øke vår evne til å gjøre det enklere for ingeniører å fokusere på å perfeksjonere arbeidsflyten sin som de samler inn fullstendig og tidsriktig informasjon. Vi forventer å se en ytelsesforbedring av applikasjoner og forbedret sikkerhet ettersom brukerne våre nå enkelt kan få tilgang til de nyeste dataene i Amazon Redshift.

– Goldman Sachs

Om forfatterne

Gagan Brahmi er en senior spesialistløsningsarkitekt med fokus på big data-analyse og AI/ML-plattform hos Amazon Web Services. Gagan har over 18 års erfaring innen informasjonsteknologi. Han hjelper kundene med å bygge og bygge svært skalerbare, ytende og sikre skybaserte løsninger på AWS. På fritiden tilbringer han tid med familien og utforsker nye steder.

Vivek Gautam er en dataarkitekt med spesialisering i datainnsjøer ved AWS Professional Services. Han jobber med bedriftskunder som bygger dataprodukter, analyseplattformer og løsninger på AWS. Når vi ikke bygger og designer datainnsjøer, er Vivek en matentusiast som også liker å utforske nye reisemål og gå på fotturer.

Naresh Gautam er en dataanalyse- og AI/ML-leder hos AWS med 20 års erfaring, som liker å hjelpe kunder med å bygge svært tilgjengelige, høyytelseseffektive og kostnadseffektive dataanalyse- og AI/ML-løsninger for å styrke kundene med datadrevet beslutningstaking . På fritiden liker han å meditere og lage mat.

Beaux Sharifi er en programvareutviklingsingeniør i Amazon Redshift-førerteamet der han leder utviklingen av Amazon Redshift-integrasjon med Apache Spark-kontakt. Han har over 20 års erfaring med å bygge datadrevne plattformer på tvers av flere bransjer. På fritiden liker han å tilbringe tid med familien og surfe.