Förenkla och snabba upp Apache Spark-applikationer på Amazon Redshift-data med Amazon Redshift-integration för Apache Spark

Återutgiven av Platon

anhängare: 0

Kunder använder Amazon RedShift att köra sin affärskritiska analys på petabyte av strukturerad och semistrukturerad data. Apache Spark är ett populärt ramverk som du kan använda för att bygga applikationer för användningsfall som ETL (extrahera, transformera och ladda), interaktiv analys och maskininlärning (ML). Apache Spark gör att du kan bygga applikationer på en mängd olika språk, som Java, Scala och Python, genom att komma åt data i ditt Amazon Redshift-datalager.

Amazon Redshift-integration för Apache Spark hjälper utvecklare att sömlöst bygga och köra Apache Spark-applikationer på Amazon Redshift-data. Utvecklare kan använda AWS-analys och ML-tjänster som t.ex Amazon EMR, AWS-limoch Amazon SageMaker att enkelt bygga Apache Spark-applikationer som läser från och skriver till deras Amazon Redshift-datalager. Du kan göra det utan att kompromissa med prestandan för dina applikationer eller transaktionskonsistensen av dina data.

I det här inlägget diskuterar vi varför Amazon Redshift-integration för Apache Spark är kritisk och effektiv för analys och ML. Dessutom diskuterar vi användningsfall som använder Amazon Redshift-integration med Apache Spark för att få affärseffekter. Slutligen går vi igenom steg-för-steg-exempel på hur du använder denna officiella AWS-kontakt i en Apache Spark-applikation.

Amazon Redshift-integration för Apache Spark

Amazon Redshift-integrationen för Apache Spark minimerar den besvärliga och ofta manuella processen att sätta upp en gniströdskiftningskontakt (community version) och förkortar tiden som behövs för att förbereda sig för analys- och ML-uppgifter. Du behöver bara ange anslutningen till ditt datalager, och du kan börja arbeta med Amazon Redshift-data från dina Apache Spark-baserade applikationer inom några minuter.

Du kan använda flera pushdown-funktioner för operationer som sorterings-, aggregerings-, limit-, join- och skalärfunktioner så att endast relevant data flyttas från ditt Amazon Redshift-datalager till den konsumerande Apache Spark-applikationen. Detta gör att du kan förbättra prestandan för dina applikationer. Amazon Redshift-administratörer kan enkelt identifiera SQL som genereras från Spark-baserade applikationer. I det här inlägget visar vi hur du kan ta reda på SQL som genereras av Apache Spark-jobbet.

Dessutom använder Amazon Redshift-integration för Apache Spark Parquet-filformat när data lagras i en tillfällig katalog. Amazon Redshift använder UNLOAD SQL-satsen för att lagra dessa temporära data Amazon enkel lagringstjänst (Amazon S3). Apache Spark-applikationen hämtar resultaten från den tillfälliga katalogen (lagrad i Parquet-filformat), vilket förbättrar prestandan.

Du kan också hjälpa till att göra dina applikationer säkrare genom att använda AWS identitets- och åtkomsthantering (IAM)-uppgifter för att ansluta till Amazon Redshift.

Amazon Redshift-integration för Apache Spark är byggd ovanpå gnist-rödförskjutningskontakten (community version) och förbättrar den för prestanda och säkerhet, vilket hjälper dig att få upp till 10 gånger snabbare applikationsprestanda.

Användningsfall för Amazon Redshift-integration med Apache Spark

För vårt användningsfall vill ledarskapet för det produktbaserade företaget veta försäljningen för varje produkt på flera marknader. Eftersom försäljningen för företaget fluktuerar dynamiskt har det blivit en utmaning för ledningen att spåra försäljningen över flera marknader. Den totala försäljningen minskar dock, och företagsledningen vill ta reda på vilka marknader som inte presterar så att de kan rikta in sig på dessa marknader för marknadsföringskampanjer.

För försäljning på flera marknader är produktförsäljningsdata som order, transaktioner och leveransdata tillgänglig på Amazon S3 i datasjön. Datateknikteamet kan använda Apache Spark med Amazon EMR eller AWS Glue för att analysera dessa data i Amazon S3.

Inventeringsdata är tillgänglig i Amazon Redshift. På samma sätt kan datateknikteamet analysera dessa data med Apache Spark med Amazon EMR eller ett AWS Glue-jobb genom att använda Amazon Redshift-integrationen för Apache Spark för att utföra aggregering och transformationer. Den aggregerade och transformerade datamängden kan lagras tillbaka i Amazon Redshift med Amazon Redshift-integrationen för Apache Spark.

Att använda ett distribuerat ramverk som Apache Spark med Amazon Redshift-integrationen för Apache Spark kan ge synlighet över datasjön och datalagret för att generera försäljningsinsikter. Dessa insikter kan göras tillgängliga för affärsintressenter och företagsanvändare i Amazon Redshift för att fatta välgrundade beslut om att köra riktade kampanjer för låginkomstmarknadssegmenten.

Dessutom kan vi använda Amazon Redshift-integrationen med Apache Spark i följande användningsfall:

En Amazon EMR- eller AWS Glue-kund som kör Apache Spark-jobb vill omvandla data och skriva det till Amazon Redshift som en del av deras ETL-pipeline
En ML-kund använder Apache Spark med SageMaker för funktionsteknik för att komma åt och transformera data i Amazon Redshift
En Amazon EMR-, AWS Glue- eller SageMaker-kund använder Apache Spark för interaktiv dataanalys med data på Amazon Redshift från bärbara datorer

Exempel på Amazon Redshift-integration för Apache Spark i en Apache Spark-applikation

I det här inlägget visar vi stegen för att ansluta Amazon Redshift från Amazon EMR på Amazon Elastic Compute Cloud (Amazon EC2), Amazon EMR-serverlös, och AWS Glue med ett vanligt skript. I följande exempelkod genererar vi en rapport som visar kvartalsförsäljningen för år 2008. För att göra det sammanfogar vi två Amazon Redshift-tabeller med hjälp av en Apache Spark DataFrame, kör en predikat pushdown, aggregerar och sorterar data, och skriver den transformerade data tillbaka till Amazon Redshift. Skriptet använder PySpark

Manuset använder IAM-baserad autentisering för Amazon Redshift. IAM-roller som används av Amazon EMR och AWS Glue bör ha lämpliga behörigheter för att autentisera Amazon Redshift och tillgång till en S3-hink för tillfällig datalagring.

Följande exempelpolicy tillåter IAM-rollen att anropa GetClusterCredentials operationer:

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

Följande exempelpolicy tillåter åtkomst till en S3-bucket för tillfällig 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 kompletta skriptet är som följer:

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()

Om du planerar att använda föregående skript i din miljö, se till att du ersätter värdena för följande variabler med lämpliga värden för din miljö: jdbc_iam_url, temp_diroch aws_role.

I nästa avsnitt går vi igenom stegen för att köra det här skriptet för att sammanställa en exempeldatauppsättning som görs tillgänglig i Amazon Redshift.

Förutsättningar

Innan vi börjar, se till att följande förutsättningar är uppfyllda:

Distribuera resurser med AWS CloudFormation

Slutför följande steg för att distribuera CloudFormation-stacken:

Logga in på AWS Management Console, starta sedan CloudFormation-stacken:

Du kan också ladda ner CloudFormation-mallen att skapa resurserna som nämns i det här inlägget genom infrastruktur som kod (IaC). Använd den här mallen när du startar en ny CloudFormation-stack.

Rulla ner till botten av sidan för att välja Jag erkänner att AWS CloudFormation kan skapa IAM-resurser under CapabilitiesOch välj sedan Skapa stack.

Processen att skapa stack tar 15–20 minuter att slutföra. CloudFormation-mallen skapar följande resurser:

- En Amazon VPC med nödvändiga undernät, rutttabeller och NAT-gateway
- En S3 hink med namnet redshift-spark-databucket-xxxxxxx (observera att xxxxxxx är en slumpmässig sträng för att göra hinknamnet unikt)
- Ett Amazon Redshift-kluster med exempeldata inlästa i databasen dev och den primära användaren redshiftmasteruser. För syftet med detta blogginlägg, redshiftmasteruser med administrativa behörigheter används. Det rekommenderas dock att använda en användare med finkornig åtkomstkontroll i produktionsmiljö.
- En IAM-roll som ska användas för Amazon Redshift med möjlighet att begära tillfälliga referenser från Amazon Redshift-klustrets utvecklingsdatabas
- Amazon EMR Studio med de nödvändiga IAM-rollerna
- Amazon EMR släpper version 6.9.0 på ett EC2-kluster med de nödvändiga IAM-rollerna
- En Amazon EMR Serverless-applikation version 6.9.0
- En AWS Glue-anslutning och AWS Glue-jobb version 4.0
- A Jupyter anteckningsbok att köra med Amazon EMR Studio med Amazon EMR på ett EC2-kluster
- Ett PySpark-skript att köra med Amazon EMR Studio och Amazon EMR Serverless

När stackskapandet är klart väljer du stacknamnet redshift-spark och navigera till Utgångarna

Vi använder dessa utdatavärden senare i det här inlägget.

I nästa avsnitt visar vi stegen för Amazon Redshift-integration för Apache Spark från Amazon EMR på Amazon EC2, Amazon EMR Serverless och AWS Glue.

Använd Amazon Redshift-integration med Apache Spark på Amazon EMR på EC2

Från och med Amazon EMR-version 6.9.0 och senare, är kontakten som använder Amazon Redshift-integration för Apache Spark och Amazon Redshift JDBC-drivrutin tillgänglig lokalt på Amazon EMR. Dessa filer finns under /usr/share/aws/redshift/ katalog. Men i de tidigare versionerna av Amazon EMR, samfundet versionen av spark-redshift kontakt är tillgänglig.

Följande exempel visar hur du ansluter Amazon Redshift med en PySpark-kärna via en Amazon EMR Studio anteckningsbok. CloudFormation-stacken skapade Amazon EMR Studio, Amazon EMR på ett EC2-kluster och en Jupyter-anteckningsbok tillgänglig att köra. För att gå igenom det här exemplet, utför följande steg:

Ladda ner Jupyter-anteckningsboken som är tillgänglig i S3-hinken för dig:
- Leta efter värdet för i CloudFormation-stackutgångarna EMRStudioNotebook, vilket bör peka på redshift-spark-emr.ipynb anteckningsbok finns i S3-hinken.
- Välj länken eller öppna länken på en ny flik genom att kopiera URL:en för anteckningsboken.
- När du har öppnat länken laddar du ner anteckningsboken genom att välja Download, vilket sparar filen lokalt på din dator.

Gå till Amazon EMR Studio genom att välja eller kopiera länken som tillhandahålls i CloudFormations stackutgångar för nyckeln EMRStudioURL.
Välj i navigeringsfönstret arbetsytor.
Välja Skapa arbetsyta.
Ange ett namn för arbetsytan, till exempel redshift-spark.
Expandera Avancerad konfiguration avsnitt och välj Anslut Workspace till ett EMR-kluster.
Enligt Fäst till ett EMR-kluster, välj EMR-klustret med namnet emrCluster-Redshift-Spark.
Välja Skapa arbetsyta.
Efter att Amazon EMR Studio-arbetsytan har skapats och i statusen Bifogad kan du komma åt arbetsytan genom att välja namnet på arbetsytan.

Detta bör öppna arbetsytan på en ny flik. Observera att om du har en popup-blockerare kan du behöva tillåta att Workspace öppnar eller inaktiverar popup-blockeraren.

I Amazon EMR Studio Workspace laddar vi nu upp Jupyter-anteckningsboken som vi laddade ner tidigare.

Välja Ladda för att bläddra i ditt lokala filsystem och ladda upp Jupyter-anteckningsboken (redshift-spark-emr.ipynb).
Välj (dubbelklicka) på redshift-spark-emr.ipynb anteckningsbok i arbetsytan för att öppna anteckningsboken.

Anteckningsboken ger information om olika uppgifter som den utför. Observera att i avsnittet Definiera variablerna för att ansluta till Amazon Redshift-kluster, behöver du inte uppdatera värdena för jdbc_iam_url, temp_diroch aws_role eftersom dessa uppdateras åt dig av AWS CloudFormation. AWS CloudFormation har också utfört de steg som nämns i Förutsättningar avsnittet i anteckningsboken.

Du kan nu börja köra anteckningsboken.

Kör de enskilda cellerna genom att markera dem och sedan välja Spela.

Du kan också använda tangentkombinationen av Skift + Enter or Skift+Retur. Alternativt kan du köra alla celler genom att välja Kör alla celler på Körning meny.

Hitta predikatets pushdown-operation som utförs på Amazon Redshift-klustret av Amazon Redshift-integrationen för Apache Spark.

Vi kan också se de tillfälliga data som lagras på Amazon S3 i det optimerade Parquet-formatet. Utdata kan ses från att köra cellen i avsnittet Få den sista frågan körd på Amazon Redshift.

För att validera tabellen som skapats av jobbet från Amazon EMR på Amazon EC2, navigera till Amazon Redshift-konsolen och välj klustret redshift-spark-redshift-cluster på Instrumentpanel för tillhandahållna kluster sida.
I klusterdetaljerna, på Fråga data meny, välj Fråga i frågeredigeraren v2.
Välj klustret i navigeringsfönstret och anslut till Amazon Redshift-klustret när det begär autentisering.
Välja Tillfälliga meriter.
För Databas, stiga på dev.
För Användarnamn, stiga på redshiftmasteruser.
Välja Save.
Expandera klustret i navigeringsfönstret redshift-spark-redshift-cluster, expandera utvecklingsdatabasen, expandera tickitoch expandera Bord för att lista alla tabeller i schemat tickit.

Du borde hitta bordet test_emr.

Välj (högerklicka) tabellen test_emrOch välj sedan Välj tabell för att fråga i tabellen.
Välja Körning för att köra SQL-satsen.

Använd Amazon Redshift-integration med Apache Spark på Amazon EMR Serverless

Amazon EMR-versionen 6.9.0 och högre tillhandahåller Amazon Redshift-integrationen för Apache Spark JAR (hanteras av Amazon Redshift) och Amazon Redshift JDBC JAR lokalt på Amazon EMR Serverless också. Dessa filer finns under /usr/share/aws/redshift/ katalog. I följande exempel använder vi Python-skriptet som gjorts tillgängligt i S3-bucketen av CloudFormation-stacken vi skapade tidigare.

Anteckna värdet för i CloudFormation-stackutgångarna EMRServerlessExecutionScript, som är platsen för Python-skriptet i S3-hinken.
Notera också värdet för EMRServerlessJobExecutionRole, vilket är IAM-rollen som ska användas för att köra Amazon EMR Serverless-jobbet.
Gå till Amazon EMR Studio genom att välja eller kopiera länken som tillhandahålls i CloudFormations stackutgångar för nyckeln EMRStudioURL.
Välja Applikationer under Server i navigeringsfönstret.

Du hittar en EMR-applikation skapad av CloudFormation-stacken med namnet emr-spark-redshift.

Välj ansökans namn för att skicka in ett jobb.
Välja Skicka jobb.
Enligt Jobb detaljer, För Namn , ange ett identifierbart namn för jobbet.
För Runtime-roll, välj IAM-rollen som du noterade från CloudFormation-stacken tidigare.
För Skriptplats, ange sökvägen till Python-skriptet du noterade tidigare från CloudFormation-stacken.
Utöka avsnittet Spark egenskaper och välj Redigera i text

Ange följande värde i textrutan, som ger sökvägen till redshift-connector, Amazon Redshift JDBC-drivrutin, spark-avro JAR och 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älja Skicka jobb.
Vänta tills jobbet är klart och körstatusen visas som framgång.
Navigera till Amazon Redshift-frågeredigeraren för att se om tabellen skapades framgångsrikt.
Kontrollera pushdown-frågorna som körs för Amazon Redshift-frågegrupp emr-serverless-redshift. Du kan köra följande SQL-sats 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 att pushdown-frågan och returresultaten lagras i Parquet-filformat på Amazon S3.

Använd Amazon Redshift-integration med Apache Spark på AWS Glue

Från och med AWS Glue version 4.0 och senare kan Apache Spark-jobb som ansluter till Amazon Redshift använda Amazon Redshift-integrationen för Apache Spark och Amazon Redshift JDBC-drivrutinen. Befintliga AWS Glue-jobb som redan använder Amazon Redshift som källa eller mål kan uppgraderas till AWS Glue 4.0 för att dra fördel av denna nya kontakt. CloudFormation-mallen som medföljer detta inlägg skapar följande AWS Glue-resurser:

AWS Limanslutning för Amazon Redshift – Anslutningen för att upprätta anslutning från AWS Glue till Amazon Redshift med Amazon Redshift-integrationen för Apache Spark
IAM-roll kopplad till AWS Glue-jobbet – IAM-rollen för att hantera behörigheter för att köra AWS Glue-jobbet
AWS limjobb – Skriptet för AWS Glue-jobbet som utför transformationer och aggregering med Amazon Redshift-integrationen för Apache Spark

Följande exempel använder AWS Glue-anslutningen som är kopplad till AWS Glue-jobbet med PySpark och inkluderar följande steg:

Välj på AWS Lim-konsolen Anslutningar i navigeringsfönstret.
Enligt Anslutningar, välj AWS Glue-anslutningen för Amazon Redshift skapad av CloudFormation-mallen.
Verifiera anslutningsdetaljerna.

Du kan nu återanvända den här anslutningen inom ett jobb eller över flera jobb.

På kontakter sida, välj AWS Glue-jobbet som skapats av CloudFormation-stacken under Dina jobb, eller få tillgång till AWS Glue-jobbet genom att använda den URL som anges för nyckeln GlueJob i CloudFormation-stackens utdata.
Få åtkomst till och verifiera skriptet för AWS Glue-jobbet.
På Jobb detaljer fliken, se till att Limversion är inställd på Lim 4.0.

Detta säkerställer att jobbet använder det senaste redshift-spark kontaktdon.

Bygga ut Avancerade egenskaper och i Anslutningar verifiera att anslutningen som skapats av CloudFormation-stacken är ansluten.
Verifiera jobbparametrarna som lagts till för AWS-limjobbet. Dessa värden är också tillgängliga i utdata för CloudFormation-stacken.
Välja Save och då Körning.

Du kan se status för jobbet som körs på Körning fliken.

När jobbkörningen har slutförts framgångsrikt kan du verifiera resultatet av tabelltestlimet som skapats av AWS Glue-jobbet.
Vi kontrollerar pushdown-frågorna som körs för Amazon Redshift-frågegrupp glue-redshift. Du kan köra följande SQL-sats mot databasen dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Bästa praxis

Tänk på följande bästa praxis:

Överväg att använda Amazon Redshift-integrationen för Apache Spark från Amazon EMR istället för att använda redshift-spark anslutning (gemenskapsversion) för dina nya Apache Spark-jobb.
Om du har befintliga Apache Spark-jobb med hjälp av redshift-spark connector (gemenskapsversion), överväg att uppgradera dem för att använda Amazon Redshift-integrationen för Apache Spark
Amazon Redshift-integrationen för Apache Spark tillämpar automatiskt predikat- och fråge-pushdown för att optimera prestanda. Vi rekommenderar att du använder funktioner som stöds (autopushdown) i din fråga. Amazon Redshift-integrationen för Apache Spark kommer att förvandla funktionen till en SQL-fråga och köra frågan i Amazon Redshift. Denna optimering resulterar i att nödvändig data hämtas, så Apache Spark kan bearbeta mindre data och ha bättre prestanda.
- Överväg att använda samlade pushdown-funktioner som avg, count, max, minoch sum för att hämta filtrerad data för databehandling.
- Överväg att använda booleska pushdown-operatorer som in, isnull, isnotnull, contains, endswithoch startswith för att hämta filtrerad data för databehandling.
- Överväg att använda logiska pushdown-operatorer som and, oroch not (eller !) för att hämta filtrerad data för databehandling.
Det rekommenderas att passera en IAM-roll med parametern aws_iam_role för Amazon Redshift-autentisering från din Apache Spark-applikation på Amazon EMR eller AWS Glue. IAM-rollen bör ha nödvändiga behörigheter för att hämta tillfälliga IAM-uppgifter för att autentisera till Amazon Redshift som visas i denna bloggs avsnitt "Exempel på Amazon Redshift-integration för Apache Spark i en Apache Spark-applikation".
Med den här funktionen behöver du inte underhålla ditt Amazon Redshift-användarnamn och lösenord i hemlighetshanteraren och Amazon Redshift-databasen.
Amazon Redshift använder UNLOAD SQL-satsen för att lagra dessa temporära data på Amazon S3. Apache Spark-applikationen hämtar resultaten från den tillfälliga katalogen (lagrad i filformatet Parquet). Den här tillfälliga katalogen på Amazon S3 rensas inte automatiskt och kan därför lägga till extra kostnader. Vi rekommenderar att du använder Amazon S3 livscykelpolicyer för att definiera retentionsreglerna för S3-skopan.
Det rekommenderas att slå på Amazon Redshift revisionsloggning för att logga informationen om anslutningar och användaraktiviteter i din databas.
Det rekommenderas att slå på Amazon Redshift-kryptering i viloläge att kryptera din data som Amazon Redshift skriver den i sina datacenter och dekrypterar den åt dig när du kommer åt den.
Det rekommenderas att uppgradera till AWS Glue v4.0 och senare för att använda Amazon Redshift-integrationen för Apache Spark, som finns tillgänglig direkt. Uppgradering till den här versionen av AWS Glue kommer automatiskt att använda denna funktion.
Det rekommenderas att uppgradera till Amazon EMR v6.9.0 och senare för att använda Amazon Redshift-integrationen för Apache Spark. Du behöver inte hantera några drivrutiner eller JAR-filer explicit.
Överväg att använda Amazon EMR Studio-anteckningsböcker för att interagera med din Amazon Redshift-data i din Apache Spark-applikation.
Överväg att använda AWS Glue Studio för att skapa Apache Spark-jobb med ett visuellt gränssnitt. Du kan också byta till att skriva Apache Spark-kod i antingen Scala eller PySpark inom AWS Glue Studio.

Städa upp

Utför följande steg för att rensa resurserna som skapas som en del av CloudFormation-mallen för att säkerställa att du inte faktureras för resurserna om du inte längre kommer att använda dem:

Stoppa Amazon EMR Serverless-applikationen:
- Gå till Amazon EMR Studio genom att välja eller kopiera länken som tillhandahålls i CloudFormations stackutgångar för nyckeln EMRStudioURL.
- Välja Applikationer under Server i navigeringsfönstret.

Du hittar en EMR-applikation skapad av CloudFormation-stacken med namnet emr-spark-redshift.

- Om programmets status visas som Stoppad kan du gå vidare till nästa steg. Men om applikationsstatusen är Startad, välj applikationens namn och välj sedan Avsluta ansökan och Avsluta ansökan igen för att bekräfta.

Ta bort Amazon EMR Studio Workspace:
- Gå till Amazon EMR Studio genom att välja eller kopiera länken som tillhandahålls i CloudFormations stackutgångar för nyckeln EMRStudioURL.
- Välja arbetsytor i navigeringsfönstret.
- Välj den arbetsyta du skapade och välj RaderaOch välj sedan Radera igen för att bekräfta.
Ta bort CloudFormation-stacken:

- På AWS CloudFormation-konsolen navigerar du till stacken du skapade tidigare.
- Välj stackens namn och välj sedan Radera för att ta bort stacken och ta bort resurserna som skapats som en del av det här inlägget.
- Välj på bekräftelseskärmen Radera stack.

Slutsats

I det här inlägget förklarade vi hur du kan använda Amazon Redshift-integrationen för Apache Spark för att bygga och distribuera applikationer med Amazon EMR på Amazon EC2, Amazon EMR Serverless och AWS Glue för att automatiskt tillämpa predikat- och fråge-pushdown för att optimera frågeprestanda för data i Amazon Redshift. Det rekommenderas starkt att använda Amazon Redshift-integration för Apache Spark för sömlös och säker anslutning till Amazon Redshift från din Amazon EMR eller AWS Glue.

Här är vad några av våra kunder har att säga om Amazon Redshift-integrationen för Apache Spark:

"Vi ger våra ingenjörer möjlighet att bygga sina datapipelines och applikationer med Apache Spark med Python och Scala. Vi ville ha en skräddarsydd lösning som förenklade driften och levererade snabbare och mer effektivt för våra kunder, och det är vad vi får med den nya Amazon Redshift-integrationen för Apache Spark.”

—Huron Consulting

"GE Aerospace använder AWS-analys och Amazon Redshift för att möjliggöra kritiska affärsinsikter som driver viktiga affärsbeslut. Med stöd för autokopiering från Amazon S3 kan vi bygga enklare datapipelines för att flytta data från Amazon S3 till Amazon Redshift. Detta accelererar våra dataproduktteams förmåga att komma åt data och leverera insikter till slutanvändare. Vi lägger mer tid på att lägga till värde genom data och mindre tid på integrationer.”

— GE Aerospace

"Vårt fokus ligger på att tillhandahålla självbetjäningsåtkomst till data för alla våra användare på Goldman Sachs. Genom Legend, vår plattform för datahantering och styrning med öppen källkod, gör vi det möjligt för användare att utveckla datacentrerade applikationer och få datadrivna insikter när vi samarbetar inom den finansiella tjänstesektorn. Med Amazon Redshift-integrationen för Apache Spark kommer vårt dataplattformsteam att kunna komma åt Amazon Redshift-data med minimala manuella steg, vilket möjliggör nollkod ETL som kommer att öka vår förmåga att göra det enklare för ingenjörer att fokusera på att fullända sitt arbetsflöde som de samlar in fullständig och aktuell information. Vi förväntar oss att se en prestandaförbättring av applikationer och förbättrad säkerhet eftersom våra användare nu enkelt kan komma åt den senaste informationen i Amazon Redshift.”

—Goldman Sachs

Om författarna

Gagan Brahmi är en Senior Specialist Solutions Architect fokuserad på big data-analys och AI/ML-plattform på Amazon Web Services. Gagan har över 18 års erfarenhet av informationsteknologi. Han hjälper kunder att utforma och bygga mycket skalbara, prestanda och säkra molnbaserade lösningar på AWS. På fritiden umgås han med sin familj och utforskar nya platser.

Vivek Gautam är en Data Architect med specialisering på datasjöar på AWS Professional Services. Han arbetar med företagskunder som bygger dataprodukter, analysplattformar och lösningar på AWS. När vi inte bygger och designar datasjöar är Vivek en matentusiast som också gillar att utforska nya resmål och åka på vandringar.

Naresh Gautam är en dataanalys- och AI/ML-ledare på AWS med 20 års erfarenhet, som tycker om att hjälpa kunder att bygga högt tillgänglig, högpresterande och kostnadseffektiv dataanalys och AI/ML-lösningar för att ge kunderna datadrivet beslutsfattande . På fritiden tycker han om att meditera och laga mat.

Beaux Sharifi är en mjukvaruutvecklingsingenjör inom Amazon Redshift-förarteamet där han leder utvecklingen av Amazon Redshift-integration med Apache Spark-kontakt. Han har över 20 års erfarenhet av att bygga datadrivna plattformar inom flera branscher. På fritiden njuter han av att umgås med familjen och surfa.