Forenkle og fremskynde Apache Spark-applikationer på Amazon Redshift-data med Amazon Redshift-integration til Apache Spark

Genudgivet af Platon

Abonnenter: 0

Kunderne bruger Amazon rødforskydning at køre deres forretningskritiske analyser på petabytes af strukturerede og semistrukturerede data. Apache Spark er en populær ramme, som du kan bruge til at bygge applikationer til brugstilfælde såsom ETL (ekstrahere, transformere og indlæse), interaktive analyser og maskinlæring (ML). Apache Spark giver dig mulighed for at bygge applikationer på en række forskellige sprog, såsom Java, Scala og Python, ved at få adgang til dataene i dit Amazon Redshift-datavarehus.

Amazon Redshift-integration til Apache Spark hjælper udviklere med at bygge og køre Apache Spark-applikationer på Amazon Redshift-data. Udviklere kan bruge AWS-analyse og ML-tjenester som f.eks Amazon EMR, AWS Limog Amazon SageMaker til ubesværet at bygge Apache Spark-applikationer, der læser fra og skriver til deres Amazon Redshift-datavarehus. Du kan gøre det uden at gå på kompromis med ydeevnen af dine applikationer eller transaktionskonsistensen af dine data.

I dette indlæg diskuterer vi, hvorfor Amazon Redshift-integration til Apache Spark er kritisk og effektiv til analyse og ML. Derudover diskuterer vi use cases, der bruger Amazon Redshift-integration med Apache Spark til at skabe forretningseffekt. Til sidst fører vi dig gennem trin-for-trin eksempler på, hvordan du bruger denne officielle AWS-stik i en Apache Spark-applikation.

Amazon Redshift-integration til Apache Spark

Amazon Redshift-integration til Apache Spark minimerer den besværlige og ofte manuelle proces med at opsætte et gnist-rødforskydningsstik (fællesskabsversion) og forkorter den tid, der er nødvendig for at forberede sig til analyse- og ML-opgaver. Du behøver kun at angive forbindelsen til dit datavarehus, og du kan begynde at arbejde med Amazon Redshift-data fra dine Apache Spark-baserede applikationer inden for få minutter.

Du kan bruge flere pushdown-funktioner til operationer såsom sorterings-, aggregerings-, limit-, join- og skalarfunktioner, så kun de relevante data flyttes fra dit Amazon Redshift-datavarehus til den forbrugende Apache Spark-applikation. Dette giver dig mulighed for at forbedre ydeevnen af dine applikationer. Amazon Redshift-administratorer kan nemt identificere SQL genereret fra Spark-baserede applikationer. I dette indlæg viser vi, hvordan du kan finde ud af den SQL, der genereres af Apache Spark-jobbet.

Desuden bruger Amazon Redshift-integration til Apache Spark Parquet-filformat, når dataene iscenesættes i en midlertidig mappe. Amazon Redshift bruger UNLOAD SQL-sætningen til at gemme disse midlertidige data på Amazon Simple Storage Service (Amazon S3). Apache Spark-applikationen henter resultaterne fra den midlertidige mappe (gemt i Parquet-filformat), hvilket forbedrer ydeevnen.

Du kan også hjælpe med at gøre dine applikationer mere sikre ved at bruge AWS identitets- og adgangsstyring (IAM) legitimationsoplysninger for at oprette forbindelse til Amazon Redshift.

Amazon Redshift-integration til Apache Spark er bygget oven på gnist-rødforskydningsstikket (fællesskabsversion) og forbedrer den for ydeevne og sikkerhed, og hjælper dig med at få op til 10 gange hurtigere applikationsydelse.

Brug cases til Amazon Redshift-integration med Apache Spark

Til vores brugssag ønsker ledelsen af den produktbaserede virksomhed at kende salget for hvert produkt på tværs af flere markeder. Da salget for virksomheden svinger dynamisk, er det blevet en udfordring for ledelsen at spore salget på tværs af flere markeder. Det samlede salg er dog faldende, og virksomhedens ledelse ønsker at finde ud af, hvilke markeder der ikke klarer sig, så de kan målrette disse markeder for salgsfremmende kampagner.

For salg på tværs af flere markeder er produktsalgsdata såsom ordrer, transaktioner og forsendelsesdata tilgængelige på Amazon S3 i datasøen. Dataingeniørteamet kan bruge Apache Spark med Amazon EMR eller AWS Glue til at analysere disse data i Amazon S3.

Lagerdataene er tilgængelige i Amazon Redshift. På samme måde kan dataingeniørteamet analysere disse data med Apache Spark ved hjælp af Amazon EMR eller et AWS Glue-job ved at bruge Amazon Redshift-integrationen til Apache Spark til at udføre aggregeringer og transformationer. Det aggregerede og transformerede datasæt kan gemmes tilbage i Amazon Redshift ved hjælp af Amazon Redshift-integrationen til Apache Spark.

Brug af en distribueret ramme som Apache Spark med Amazon Redshift-integrationen til Apache Spark kan give synlighed på tværs af datasøen og datavarehuset for at generere salgsindsigt. Disse indsigter kan stilles til rådighed for forretningsinteressenter og branchebrugere i Amazon Redshift for at træffe informerede beslutninger om at køre målrettede kampagner til markedssegmenterne med lav indtjening.

Derudover kan vi bruge Amazon Redshift-integrationen med Apache Spark i følgende tilfælde:

En Amazon EMR- eller AWS Glue-kunde, der kører Apache Spark-job, ønsker at transformere data og skrive dem ind i Amazon Redshift som en del af deres ETL-pipeline
En ML-kunde bruger Apache Spark med SageMaker til feature engineering til at få adgang til og transformere data i Amazon Redshift
En Amazon EMR-, AWS Glue- eller SageMaker-kunde bruger Apache Spark til interaktiv dataanalyse med data på Amazon Redshift fra notebooks

Eksempler på Amazon Redshift-integration til Apache Spark i en Apache Spark-applikation

I dette indlæg viser vi trinene til at forbinde Amazon Redshift fra Amazon EMR på Amazon Elastic Compute Cloud (Amazon EC2), Amazon EMR-serverløs, og AWS Glue ved hjælp af et almindeligt script. I den følgende eksempelkode genererer vi en rapport, der viser det kvartalsvise salg for år 2008. For at gøre det samler vi to Amazon Redshift-tabeller ved hjælp af en Apache Spark DataFrame, kører et prædikat-pushdown, samler og sorterer dataene og skriver de transformerede data tilbage til Amazon Redshift. Scriptet bruger PySpark

Scriptet bruger IAM-baseret godkendelse til Amazon Redshift. IAM-roller, der bruges af Amazon EMR og AWS Glue, skal have de relevante tilladelser til at autentificere Amazon Redshift og adgang til en S3-bøtte til midlertidig datalagring.

Følgende eksempelpolitik tillader IAM-rollen at kalde GetClusterCredentials operationer:

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

Følgende eksempelpolitik giver adgang til en S3-bøtte til 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 script 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 planlægger at bruge det foregående script i dit miljø, skal du sørge for at erstatte værdierne for følgende variabler med de relevante værdier for dit miljø: jdbc_iam_url, temp_dirog aws_role.

I det næste afsnit gennemgår vi trinene til at køre dette script for at samle et eksempeldatasæt, der er gjort tilgængeligt i Amazon Redshift.

Forudsætninger

Før vi begynder, skal du sørge for, at følgende forudsætninger er opfyldt:

Implementer ressourcer ved hjælp af AWS CloudFormation

Fuldfør følgende trin for at implementere CloudFormation-stakken:

Log ind på AWS Management Console, og start derefter CloudFormation-stakken:

Du kan også download CloudFormation skabelonen at skabe ressourcerne nævnt i dette indlæg gennem infrastruktur som kode (IaC). Brug denne skabelon, når du starter en ny CloudFormation-stak.

Rul ned til bunden af siden for at vælge Jeg anerkender, at AWS CloudFormation kan skabe IAM-ressourcer under Capabilities, Og vælg derefter Opret stak.

Processen til at oprette stakken tager 15-20 minutter at fuldføre. CloudFormation-skabelonen opretter følgende ressourcer:

- En Amazon VPC med de nødvendige undernet, rutetabeller og NAT-gateway
- En S3 spand med navnet redshift-spark-databucket-xxxxxxx (bemærk, at xxxxxxx er en tilfældig streng for at gøre bøttenavnet unikt)
- En Amazon Redshift-klynge med eksempeldata indlæst i databasen dev og den primære bruger redshiftmasteruser. Med henblik på dette blogindlæg, redshiftmasteruser med administrative tilladelser bruges. Det anbefales dog at bruge en bruger med finkornet adgangskontrol i produktionsmiljøet.
- En IAM-rolle, der skal bruges til Amazon Redshift med mulighed for at anmode om midlertidige legitimationsoplysninger fra Amazon Redshift-klyngens udviklingsdatabase
- Amazon EMR Studio med de nødvendige IAM-roller
- Amazon EMR udgiver version 6.9.0 på en EC2-klynge med de nødvendige IAM-roller
- En Amazon EMR Serverless-applikationsudgivelse version 6.9.0
- En AWS Glue-forbindelse og AWS Glue-job version 4.0
- A Jupyter notesbog at køre ved hjælp af Amazon EMR Studio ved hjælp af Amazon EMR på en EC2-klynge
- Et PySpark-script til at køre ved hjælp af Amazon EMR Studio og Amazon EMR Serverless

Når stakken er oprettet, skal du vælge staknavnet redshift-spark og naviger til Udgange

Vi bruger disse outputværdier senere i dette indlæg.

I de næste afsnit viser vi trinene til Amazon Redshift-integration til Apache Spark fra Amazon EMR på Amazon EC2, Amazon EMR Serverless og AWS Glue.

Brug Amazon Redshift-integration med Apache Spark på Amazon EMR på EC2

Fra Amazon EMR-udgivelsesversion 6.9.0 og nyere er forbindelsen, der bruger Amazon Redshift-integration til Apache Spark og Amazon Redshift JDBC-driver, tilgængelig lokalt på Amazon EMR. Disse filer er placeret under /usr/share/aws/redshift/ vejviser. Men i de tidligere versioner af Amazon EMR, den samfund version af spark-redshift stik er tilgængelig.

Følgende eksempel viser, hvordan man forbinder Amazon Redshift ved hjælp af en PySpark-kerne via en Amazon EMR Studio notesbog. CloudFormation-stakken skabte Amazon EMR Studio, Amazon EMR på en EC2-klynge og en Jupyter-notebook, der kunne køres. For at gennemgå dette eksempel skal du udføre følgende trin:

Download Jupyter-notesbogen, der er tilgængelig i S3-bøtten til dig:
- I CloudFormations stak-output skal du se efter værdien for EMRStudioNotebook, som skulle pege på redshift-spark-emr.ipynb notebook tilgængelig i S3-bøtten.
- Vælg linket, eller åbn linket i en ny fane ved at kopiere URL'en til notesbogen.
- Når du har åbnet linket, skal du downloade notesbogen ved at vælge Hent, som gemmer filen lokalt på din computer.

Få adgang til Amazon EMR Studio ved at vælge eller kopiere det link, der er angivet i CloudFormations stak-output for nøglen EMRStudioURL.
Vælg i navigationsruden arbejdsområder.
Vælg Opret arbejdsområde.
Angiv for eksempel et navn til arbejdsområdet redshift-spark.
Udvid Avanceret konfiguration sektion og vælg Tilslut Workspace til en EMR-klynge.
Under Tilslut til en EMR-klynge, vælg EMR-klyngen med navnet emrCluster-Redshift-Spark.
Vælg Opret arbejdsområde.
Efter at Amazon EMR Studio Workspace er oprettet og i vedhæftet status, kan du få adgang til Workspace ved at vælge navnet på Workspace.

Dette skulle åbne arbejdsområdet i en ny fane. Bemærk, at hvis du har en pop op-blokering, skal du muligvis tillade, at Workspace åbner eller deaktiverer pop-up-blokering.

I Amazon EMR Studio Workspace uploader vi nu Jupyter-notesbogen, vi downloadede tidligere.

Vælg Upload for at gennemse dit lokale filsystem og uploade Jupyter-notesbogen (redshift-spark-emr.ipynb).
Vælg (dobbeltklik) på redshift-spark-emr.ipynb notesbog i arbejdsområdet for at åbne notesbogen.

Notesbogen giver detaljerne om forskellige opgaver, som den udfører. Bemærk det i afsnittet Definer variablerne, der skal oprettes forbindelse til Amazon Redshift-klyngen, behøver du ikke at opdatere værdierne for jdbc_iam_url, temp_dirog aws_role fordi disse er opdateret for dig af AWS CloudFormation. AWS CloudFormation har også udført de trin, der er nævnt i Forudsætninger del af notesbogen.

Du kan nu begynde at køre notesbogen.

Kør de enkelte celler ved at markere dem og derefter vælge Leg.

Du kan også bruge tastekombinationen af Skift + Enter or Shift+Retur. Alternativt kan du køre alle cellerne ved at vælge Kør alle celler på den Kør menu.

Find prædikat-pushdown-operationen udført på Amazon Redshift-klyngen af Amazon Redshift-integrationen til Apache Spark.

Vi kan også se de midlertidige data gemt på Amazon S3 i det optimerede Parket-format. Outputtet kan ses ved at køre cellen i afsnittet Få den sidste forespørgsel udført på Amazon Redshift.

For at validere tabellen oprettet af jobbet fra Amazon EMR på Amazon EC2 skal du navigere til Amazon Redshift-konsollen og vælge klyngen redshift-spark-redshift-cluster på den Provisionerede klynger dashboard .
I klyngedetaljerne på Forespørg data menu, vælg Forespørgsel i forespørgselseditor v2.
Vælg klyngen i navigationsruden, og opret forbindelse til Amazon Redshift-klyngen, når den anmoder om godkendelse.
Type Midlertidige legitimationsoplysninger.
Til Database, gå ind dev.
Til brugernavn, gå ind redshiftmasteruser.
Vælg Gem.
Udvid klyngen i navigationsruden redshift-spark-redshift-cluster, udvid udviklerdatabasen, udvid tickit, og udvide tabeller for at liste alle tabellerne inde i skemaet tickit.

Du burde finde bordet test_emr.

Vælg (højreklik) tabellen test_emr, Og vælg derefter Vælg bord for at forespørge i tabellen.
Vælg Kør for at køre SQL-sætningen.

Brug Amazon Redshift-integration med Apache Spark på Amazon EMR Serverless

Amazon EMR-udgivelsesversion 6.9.0 og nyere giver Amazon Redshift-integration til Apache Spark JAR'er (administreret af Amazon Redshift) og Amazon Redshift JDBC JAR'er også lokalt på Amazon EMR Serverless. Disse filer er placeret under /usr/share/aws/redshift/ vejviser. I det følgende eksempel bruger vi Python-scriptet, der er gjort tilgængeligt i S3-bøtten af CloudFormation-stakken, vi oprettede tidligere.

I CloudFormations stak-output skal du notere værdien for EMRServerlessExecutionScript, som er placeringen af Python-scriptet i S3-bøtten.
Bemærk også værdien for EMRServerlessJobExecutionRole, som er IAM-rollen, der skal bruges til at køre Amazon EMR Serverless-jobbet.
Få adgang til Amazon EMR Studio ved at vælge eller kopiere det link, der er angivet i CloudFormations stak-output for nøglen EMRStudioURL.
Vælg Applikationer under Serverless i navigationsruden.

Du vil finde en EMR-applikation oprettet af CloudFormation-stakken med navnet emr-spark-redshift.

Vælg ansøgningsnavnet for at indsende et job.
Vælg Send job.
Under Joboplysninger, For Navn, indtast et identificerbart navn for jobbet.
Til Runtime rolle, skal du vælge den IAM-rolle, som du noterede fra CloudFormations stak-output tidligere.
Til Script placering, angiv stien til det Python-script, du noterede tidligere fra CloudFormations stak-output.
Udvid afsnittet Spark egenskaber og vælg Rediger i tekst

Indtast følgende værdi i tekstboksen, som angiver stien 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

Vælg Send job.
Vent på, at jobbet er fuldført, og kørselsstatus vises som Succes.
Naviger til Amazon Redshift-forespørgselseditoren for at se, om tabellen blev oprettet.
Tjek pushdown-forespørgslerne til Amazon Redshift-forespørgselsgruppe emr-serverless-redshift. Du kan køre følgende SQL-sætning mod 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-forespørgslen og returneringsresultaterne er gemt i Parquet-filformat på Amazon S3.

Brug Amazon Redshift-integration med Apache Spark på AWS Glue

Fra og med AWS Glue version 4.0 og nyere kan Apache Spark-job, der forbinder til Amazon Redshift, bruge Amazon Redshift-integration til Apache Spark og Amazon Redshift JDBC-driver. Eksisterende AWS Glue-job, der allerede bruger Amazon Redshift som kilde eller mål, kan opgraderes til AWS Glue 4.0 for at drage fordel af denne nye forbindelse. CloudFormation-skabelonen, der følger med dette indlæg, skaber følgende AWS Glue-ressourcer:

AWS Limforbindelse til Amazon Redshift – Forbindelsen til at etablere forbindelse fra AWS Glue til Amazon Redshift ved hjælp af Amazon Redshift-integrationen til Apache Spark
IAM-rolle knyttet til AWS Glue-jobbet – IAM-rollen til at administrere tilladelser til at køre AWS Glue-jobbet
AWS lim job – Scriptet til AWS Glue-jobbet, der udfører transformationer og aggregeringer ved hjælp af Amazon Redshift-integration til Apache Spark

Følgende eksempel bruger AWS Glue-forbindelsen knyttet til AWS Glue-jobbet med PySpark og inkluderer følgende trin:

På AWS Glue-konsollen skal du vælge Tilslutninger i navigationsruden.
Under Tilslutninger, vælg AWS Glue-forbindelsen til Amazon Redshift, der er oprettet af CloudFormation-skabelonen.
Bekræft forbindelsesdetaljerne.

Du kan nu genbruge denne forbindelse inden for et job eller på tværs af flere job.

På Stik side, skal du vælge AWS Glue-job, der er oprettet af CloudFormation-stakken under Dine jobs, eller få adgang til AWS Glue-jobbet ved at bruge den URL, der er angivet for nøglen GlueJob i CloudFormations stak-output.
Få adgang til og bekræft scriptet til AWS Glue-jobbet.
På Joboplysninger fanen, sørg for at Lim version er sat til Lim 4.0.

Dette sikrer, at jobbet bruger det nyeste redshift-spark stik.

Udvid Avancerede egenskaber og i Tilslutninger sektion, skal du kontrollere, at forbindelsen oprettet af CloudFormation-stakken er knyttet.
Bekræft jobparametrene, der er tilføjet for AWS Lim-jobbet. Disse værdier er også tilgængelige i outputtet for CloudFormation-stakken.
Vælg Gem og så Kør.

Du kan se status for jobkørsel på Kør fane.

Når jobkørslen er fuldført, kan du verificere outputtet af tabeltestlimen, der er oprettet af AWS Glue-jobbet.
Vi tjekker pushdown-forespørgslerne, der køres for Amazon Redshift-forespørgselsgruppe glue-redshift. Du kan køre følgende SQL-sætning mod databasen dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Bedste praksis

Husk følgende bedste praksis:

Overvej at bruge Amazon Redshift-integrationen til Apache Spark fra Amazon EMR i stedet for at bruge redshift-spark stik (fællesskabsversion) til dine nye Apache Spark-job.
Hvis du har eksisterende Apache Spark-job ved hjælp af redshift-spark connector (fællesskabsversion), overvej at opgradere dem til at bruge Amazon Redshift-integrationen til Apache Spark
Amazon Redshift-integrationen til Apache Spark anvender automatisk prædikat- og forespørgsels-pushdown for at optimere ydeevnen. Vi anbefaler at bruge understøttede funktioner (autopushdown) i din forespørgsel. Amazon Redshift-integrationen til Apache Spark vil gøre funktionen til en SQL-forespørgsel og køre forespørgslen i Amazon Redshift. Denne optimering resulterer i, at nødvendige data hentes, så Apache Spark kan behandle færre data og have bedre ydeevne.
- Overvej at bruge samlede pushdown-funktioner som f.eks avg, count, max, minog sum at hente filtrerede data til databehandling.
- Overvej at bruge booleske pushdown-operatorer som in, isnull, isnotnull, contains, endswithog startswith at hente filtrerede data til databehandling.
- Overvej at bruge logiske pushdown-operatører som and, orog not (eller !) for at hente filtrerede data til databehandling.
Det anbefales at bestå en IAM-rolle ved hjælp af parameteren aws_iam_role til Amazon Redshift-godkendelse fra din Apache Spark-applikation på Amazon EMR eller AWS Glue. IAM-rollen skal have nødvendige tilladelser til at hente midlertidige IAM-legitimationsoplysninger for at godkende til Amazon Redshift som vist i denne blogs "Eksempler på Amazon Redshift-integration til Apache Spark i en Apache Spark-applikation".
Med denne funktion behøver du ikke at vedligeholde dit Amazon Redshift-brugernavn og din adgangskode i Secrets Manager og Amazon Redshift-databasen.
Amazon Redshift bruger UNLOAD SQL-sætningen til at gemme disse midlertidige data på Amazon S3. Apache Spark-applikationen henter resultaterne fra den midlertidige mappe (gemt i Parquet-filformat). Denne midlertidige mappe på Amazon S3 bliver ikke ryddet op automatisk og kan derfor medføre ekstra omkostninger. Vi anbefaler at bruge Amazon S3 livscykluspolitikker for at definere opbevaringsreglerne for S3-spanden.
Det anbefales at tænde Amazon Redshift revisionslogning at logge oplysningerne om forbindelser og brugeraktiviteter i din database.
Det anbefales at tænde Amazon Redshift i hvile kryptering at kryptere dine data, som Amazon Redshift skriver dem i sine datacentre og dekryptere dem for dig, når du får adgang til dem.
Det anbefales at opgradere til AWS Glue v4.0 og nyere for at bruge Amazon Redshift-integrationen til Apache Spark, som er tilgængelig ud af æsken. Opgradering til denne version af AWS Glue vil automatisk gøre brug af denne funktion.
Det anbefales at opgradere til Amazon EMR v6.9.0 og nyere for at bruge Amazon Redshift-integrationen til Apache Spark. Du behøver ikke at administrere nogen drivere eller JAR-filer eksplicit.
Overvej at bruge Amazon EMR Studio-notebooks til at interagere med dine Amazon Redshift-data i din Apache Spark-applikation.
Overvej at bruge AWS Glue Studio til at oprette Apache Spark-job ved hjælp af en visuel grænseflade. Du kan også skifte til at skrive Apache Spark-kode i enten Scala eller PySpark i AWS Glue Studio.

Ryd op

Udfør følgende trin for at rydde op i de ressourcer, der er oprettet som en del af CloudFormation-skabelonen for at sikre, at du ikke bliver faktureret for ressourcerne, hvis du ikke længere vil bruge dem:

Stop Amazon EMR Serverless-applikationen:
- Få adgang til Amazon EMR Studio ved at vælge eller kopiere det link, der er angivet i CloudFormations stak-output for nøglen EMRStudioURL.
- Vælg Applikationer under Serverless i navigationsruden.

Du vil finde en EMR-applikation oprettet af CloudFormation-stakken med navnet emr-spark-redshift.

- Hvis applikationsstatus viser som Stoppet, kan du gå videre til de næste trin. Men hvis applikationsstatus er Startet, skal du vælge applikationsnavnet og derefter vælge Stop ansøgning , Stop ansøgning igen for at bekræfte.

Slet Amazon EMR Studio Workspace:
- Få adgang til Amazon EMR Studio ved at vælge eller kopiere det link, der er angivet i CloudFormations stak-output for nøglen EMRStudioURL.
- Vælg arbejdsområder i navigationsruden.
- Vælg det arbejdsområde, du har oprettet, og vælg Slette, Og vælg derefter Slette igen for at bekræfte.
Slet CloudFormation-stakken:

- På AWS CloudFormation-konsollen skal du navigere til den stak, du oprettede tidligere.
- Vælg staknavnet, og vælg derefter Slette for at fjerne stakken og slette de ressourcer, der er oprettet som en del af dette indlæg.
- Vælg på bekræftelsesskærmen Slet stakken.

Konklusion

I dette indlæg forklarede vi, hvordan du kan bruge Amazon Redshift-integrationen til Apache Spark til at bygge og implementere applikationer med Amazon EMR på Amazon EC2, Amazon EMR Serverless og AWS Glue til automatisk at anvende prædikat- og forespørgsels-pushdown for at optimere forespørgselsydeevnen for data i Amazon Redshift. Det anbefales stærkt at bruge Amazon Redshift-integration til Apache Spark for en problemfri og sikker forbindelse til Amazon Redshift fra din Amazon EMR eller AWS Glue.

Her er, hvad nogle af vores kunder har at sige om Amazon Redshift-integrationen til Apache Spark:

"Vi giver vores ingeniører mulighed for at bygge deres datapipelines og applikationer med Apache Spark ved hjælp af Python og Scala. Vi ønskede en skræddersyet løsning, der forenklede driften og leverede hurtigere og mere effektivt til vores kunder, og det er, hvad vi får med den nye Amazon Redshift-integration til Apache Spark.”

-Huron Consulting

"GE Aerospace bruger AWS-analyse og Amazon Redshift til at muliggøre kritisk forretningsindsigt, der driver vigtige forretningsbeslutninger. Med understøttelsen af autokopiering fra Amazon S3 kan vi bygge enklere datapipelines til at flytte data fra Amazon S3 til Amazon Redshift. Dette accelererer vores dataproduktteams evne til at få adgang til data og levere indsigt til slutbrugere. Vi bruger mere tid på at tilføje værdi gennem data og mindre tid på integrationer."

—GE Aerospace

"Vores fokus er på at give selvbetjeningsadgang til data for alle vores brugere hos Goldman Sachs. Gennem Legend, vores open source-dataadministrations- og styringsplatform, giver vi brugerne mulighed for at udvikle datacentrerede applikationer og udlede datadrevet indsigt, mens vi samarbejder på tværs af den finansielle serviceindustri. Med Amazon Redshift-integrationen til Apache Spark vil vores dataplatformsteam være i stand til at få adgang til Amazon Redshift-data med minimale manuelle trin, hvilket giver mulighed for nulkode ETL, der vil øge vores evne til at gøre det nemmere for ingeniører at fokusere på at perfektionere deres workflow som de indsamler fuldstændige og rettidige oplysninger. Vi forventer at se en ydelsesforbedring af applikationer og forbedret sikkerhed, da vores brugere nu nemt kan få adgang til de nyeste data i Amazon Redshift."

-Goldman Sachs

Om forfatterne

Gagan Brahmi er en Senior Specialist Solutions Architect med fokus på big data analytics og AI/ML platform hos Amazon Web Services. Gagan har over 18 års erfaring inden for informationsteknologi. Han hjælper kunder med at udforme og bygge meget skalerbare, effektive og sikre cloud-baserede løsninger på AWS. I sin fritid bruger han tid sammen med sin familie og udforsker nye steder.

Vivek Gautam er dataarkitekt med speciale i datasøer hos AWS Professional Services. Han arbejder med virksomhedskunder, der bygger dataprodukter, analyseplatforme og løsninger på AWS. Når vi ikke bygger og designer datasøer, er Vivek en madentusiast, der også kan lide at udforske nye rejsedestinationer og tage på vandreture.

Naresh Gautam er en dataanalyse- og AI/ML-leder hos AWS med 20 års erfaring, som nyder at hjælpe kunder med at bygge højtilgængelige, højtydende og omkostningseffektive dataanalyse- og AI/ML-løsninger for at give kunderne datadrevet beslutningstagning . I sin fritid nyder han at meditere og lave mad.

Beaux Sharifi er softwareudviklingsingeniør i Amazon Redshift-chaufførteamet, hvor han leder udviklingen af Amazon Redshift-integration med Apache Spark-stik. Han har over 20 års erfaring med at bygge datadrevne platforme på tværs af flere brancher. I sin fritid nyder han at bruge tid med sin familie og surfe.