Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Abfragen mit benutzerdefinierten Funktionen Mit benutzerdefinierten Funktionen (UDF) in Amazon Athena können Sie eigene Funktionen zum Verarbeiten von Datensätzen oder Datensatzgruppen erstellen. Eine UDF akzeptiert Parameter, führt Arbeit aus und gibt dann ein Ergebnis zurück. Um eine UDF in Athena zu verwenden, schreiben Sie eine `USING EXTERNAL FUNCTION`-Klausel vor eine `SELECT`-Anweisung in einer SQL-Abfrage. Die `SELECT`-Anweisung verweist auf die UDF und definiert die Variablen, die beim Ausführen der Abfrage an die UDF übergeben werden. Die SQL-Abfrage ruft eine Lambda-Funktion unter Verwendung der Java-Laufzeit auf, wenn sie die UDF aufruft. UDFssind innerhalb der Lambda-Funktion als Methoden in einem Java-Bereitstellungspaket definiert. In demselben Java-Bereitstellungspaket UDFs können mehrere für eine Lambda-Funktion definiert werden. Sie geben auch den Namen der Lambda-Funktion in der `USING EXTERNAL FUNCTION`-Klausel an. Sie haben zwei Möglichkeiten, eine Lambda-Funktion für UDFs Athena bereitzustellen. Sie können die Funktion direkt mit Lambda bereitstellen, oder Sie können die AWS Serverless Application Repository verwenden. Um nach vorhandenen Lambda-Funktionen für zu suchen UDFs, können Sie das öffentliche AWS Serverless Application Repository oder Ihr privates Repository durchsuchen und dann auf Lambda bereitstellen. Sie können auch Java-Quellcode erstellen oder ändern, ihn in eine JAR-Datei verpacken und mit Lambda oder dem AWS Serverless Application Repository bereitstellen. Beispiele für Java-Quellcode und -Pakete für den Einstieg finden Sie unter [Erstellen und Bereitstellen einer UDF mit Lambda](udf-creating-and-deploying.md). Weitere Informationen zu Lambda finden Sie im [AWS Lambda -Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/). Weitere Informationen AWS Serverless Application Repository dazu finden Sie im [AWS Serverless Application Repository Entwicklerhandbuch](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/). Ein Beispiel, das UDFs mit Athena zur Übersetzung und Analyse von Text verwendet wird, finden Sie im Blogartikel AWS Machine Learning [Translate and analyze text using SQL functions with Amazon Athena, Amazon Translate und Amazon Comprehend, oder](https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-athena-amazon-translate-and-amazon-comprehend/) schauen Sie sich den an. [video](udf-videos.md#udf-videos-xlate) *Ein Beispiel für die Verwendung UDFs zur Erweiterung von Geodatenabfragen in Amazon Athena finden Sie unter [Erweitern von Geodatenabfragen in Amazon Athena mit UDFs und AWS Lambda](https://aws.amazon.com/blogs/big-data/extend-geospatial-queries-in-amazon-athena-with-udfs-and-aws-lambda/) im AWS Big Data-Blog.* **Topics** + [Videos über UDFs In Athena](udf-videos.md) + [Überlegungen und Einschränkungen](udf-considerations-limitations.md) + [Abfragen mit UDF-Abfragesyntax](udf-query-syntax.md) + [Erstellen und Bereitstellen einer UDF mit Lambda](udf-creating-and-deploying.md) # Videos über UDFs In Athena Sehen Sie sich die folgenden Videos an, um mehr über die Verwendung UDFs in Athena zu erfahren. **Video: Einführung von benutzerdefinierten Funktionen (UDFs) in Amazon Athena** Das folgende Video zeigt, wie Sie UDFs in Amazon Athena vertrauliche Informationen redigieren können. **Anmerkung** Die Syntax in diesem Video ist Vorabversion, aber die Konzepte sind die gleichen. Verwenden Sie Athena ohne die `AmazonAthenaPreviewFunctionality`-Arbeitsgruppe. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/AxJ6jP4Pfmo/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/AxJ6jP4Pfmo) **Video: Übersetzen, analysieren und redigieren Sie Textfelder mithilfe von SQL-Abfragen in Amazon Athena** Das folgende Video zeigt, wie Sie UDFs in Amazon Athena zusammen mit anderen verwenden können, um Text AWS-Services zu übersetzen und zu analysieren. **Anmerkung** Die Syntax in diesem Video ist Vorabversion, aber die Konzepte sind die gleichen. Die korrekte Syntax finden Sie im zugehörigen Blogbeitrag [Übersetzen, redigieren und analysieren Sie Text mithilfe von SQL-Funktionen mit Amazon Athena, Amazon Translate und Amazon Comprehend](https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-athena-amazon-translate-and-amazon-comprehend/) im *AWS -Machine-Learning-Blog*. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/Od7rXG-WMO4/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Od7rXG-WMO4) # Überlegungen und Einschränkungen Beachten Sie die folgenden Punkte, wenn Sie die benutzerdefinierte Funktion (UDFs) in Athena verwenden. + **Integrierte Athena Funktionen** – Integrierte Funktionen in Athena sind so konzipiert, dass sie sehr leistungsfähig sind. Wir empfehlen, UDFs wenn möglich die integrierten Funktionen zu verwenden. Weitere Hinweise zu integrierten Funktionen finden Sie unter [Funktionen in Amazon Athena](functions.md). + ** UDFs Nur Skalar** — Athena unterstützt nur Skalare UDFs, die jeweils eine Zeile verarbeiten und einen einzelnen Spaltenwert zurückgeben. Athena übergibt einen Batch von Zeilen, möglicherweise parallel, an die UDF, wenn Lambda aufgerufen wird. Beachten Sie beim Entwerfen UDFs und Abfragen die möglichen Auswirkungen dieser Verarbeitung auf den Netzwerkverkehr. + **UDF-Handler-Funktionen verwenden ein abgekürztes Format** — Verwenden Sie das abgekürzte Format (kein Vollformat) für Ihre UDF-Funktionen (z. B. `package.Class` anstelle von`package.Class::method`). + **UDF-Methoden müssen in Kleinbuchstaben sein** — UDF-Methoden müssen in Kleinbuchstaben vorliegen; Kamelschreibung ist nicht zulässig. + **UDF-Methoden benötigen Parameter** – UDF-Methoden müssen mindestens einen Eingabeparameter haben. Der Versuch, eine ohne Eingabeparameter definierte UDF aufzurufen, führt zu einer Laufzeitausnahme. UDFs sind dazu gedacht, Funktionen für Datensätze auszuführen, aber eine UDF ohne Argumente nimmt keine Daten auf, sodass eine Ausnahme auftritt. + **Java-Laufzeitunterstützung** — Derzeit unterstützt Athena UDFs die Java 8-, Java 11- und Java 17-Laufzeiten für Lambda. Weitere Informationen finden Sie unter [entwickeln von Lambda-Funktionen mit Java](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java.html) im *AWS Lambda -Entwicklerhandbuch*. **Anmerkung** Für Java 17 müssen Sie den Wert der `JAVA_TOOL_OPTIONS`-Umgebungsvariable wie `--add-opens=java.base/java.nio=ALL-UNNAMED` in Ihrem Lambda festlegen. + **IAM-Berechtigungen** – Um UDF-Abfrageanweisungen in Athena auszuführen und zu erstellen, muss der IAM-Prinzipal, der die Abfrage ausführt, zusätzlich zu den Athena-Funktionen auch Aktionen ausführen dürfen. Weitere Informationen finden Sie unter [Zugriff auf Athena zulassen UDFs: Beispielrichtlinien](udf-iam-access.md). + **Lambda-Kontingente** — Lambda-Kontingente gelten für. UDFs Weitere Informationen finden Sie unter [Lambda quotas (Lambda-Kontingente)](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) im *AWS Lambda -Entwicklerhandbuch.* + **Filterung auf Zeilenebene — Die Filterung auf** Zeilenebene von Lake Formation wird nicht unterstützt. UDFs + **Ansichten** — Sie können Ansichten nicht mit verwenden. UDFs + **Bekannte Probleme** — Eine vollständige up-to-date Liste der bekannten Probleme finden Sie unter [Einschränkungen und Probleme im Abschnitt](https://github.com/awslabs/aws-athena-query-federation/wiki/Limitations_And_Issues) awslabs/ aws-athena-query-federation von. GitHub # Abfragen mit UDF-Abfragesyntax Die `USING EXTERNAL FUNCTION` Klausel gibt eine oder mehrere UDFs an, auf UDFs die in einer nachfolgenden `SELECT` Anweisung in der Abfrage verwiesen werden kann. Sie benötigen den Methodennamen für die UDF und den Namen der Lambda-Funktion, die die UDF hostet. Anstelle des Lambda-Funktionsnamens können Sie den Lambda-ARN verwenden. In kontenübergreifenden Szenarien ist der Lambda-ARN erforderlich. ## Syntax ``` USING EXTERNAL FUNCTION UDF_name(variable1 data_type[, variable2 data_type][,...]) RETURNS data_type LAMBDA 'lambda_function_name_or_ARN' [, EXTERNAL FUNCTION UDF_name2(variable1 data_type[, variable2 data_type][,...]) RETURNS data_type LAMBDA 'lambda_function_name_or_ARN'[,...]] SELECT [...] UDF_name(expression) [, UDF_name2(expression)] [...] ``` ## Parameters **VERWENDUNG DER EXTERNEN FUNKTION *UDF\$1name* (*variable1**data\$1type*[, *variable2**data\$1type*] [,...])** *UDF\$1name*gibt den Namen der UDF an, der einer Java-Methode innerhalb der referenzierten Lambda-Funktion entsprechen muss. Jede *variable data\$1type* gibt eine benannte Variable und den entsprechenden Datentyp an, den die UDF als Eingabe akzeptiert. Der *data\$1type* muss einer der unterstützten Athena-Datentypen sein, die in der folgenden Tabelle aufgeführt sind und dem entsprechenden Java-Datentyp zugeordnet sein. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/udf-query-syntax.html) **RÜCKSENDUNGEN *data\$1type*** `data_type` gibt den SQL-Datentyp an, den die UDF als Ausgabe zurückgibt. Athena Datentypen, die in der obigen Tabelle aufgeführt sind, werden unterstützt. Verwenden Sie für den `DECIMAL` Datentyp die Syntax, `RETURNS DECIMAL(precision, scale)` wobei *precision* und Ganzzahlen *scale* sind. **LAMBDA '' *lambda\$1function*** *lambda\$1function*gibt den Namen der Lambda-Funktion an, die beim Ausführen der UDF aufgerufen werden soll. **WÄHLEN SIE [...] *UDF\$1name*(*expression*) [...]** Die `SELECT` Abfrage, die Werte an die UDF übergibt und ein Ergebnis zurückgibt. *UDF\$1name*gibt die zu verwendende UDF an, gefolgt von einer, *expression* die ausgewertet wird, um Werte zu übergeben. Werte, die übergeben und zurückgegeben werden, müssen mit den entsprechenden Datentypen übereinstimmen, die für die UDF in der `USING EXTERNAL FUNCTION`-Klausel angegeben sind. ### Beispiele Beispiele für Abfragen, die auf dem [UDFHandlerAthena-.java-Code](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/src/main/java/com/amazonaws/athena/connectors/udfs/AthenaUDFHandler.java) basieren GitHub, finden Sie auf der GitHub [Amazon Athena UDF-Connector-Seite](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-udfs). # Erstellen und Bereitstellen einer UDF mit Lambda Um eine eigene UDF zu erstellen, erstellen Sie eine neue Java-Klasse, indem Sie die `UserDefinedFunctionHandler`-Klasse erweitern. Der Quellcode für die Datei [UserDefinedFunctionHandler.java](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java) im SDK ist im [Repository awslabs/aws-athena-query-federation/athena](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk) -federation-sdk verfügbar GitHub , zusammen mit [Beispiel-UDF-Implementierungen](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-udfs), die Sie untersuchen und ändern können, um eine benutzerdefinierte UDF zu erstellen. Die Schritte in diesem Abschnitt veranschaulichen das Schreiben und Erstellen einer benutzerdefinierten UDF-JAR-Datei mit [Apache Maven](https://maven.apache.org/index.html) über die Befehlszeile und eine Bereitstellung. Führen Sie die folgenden Schritte aus, um mit Maven eine benutzerdefinierte UDF für Athena zu erstellen 1. [Klonen des SDK und Vorbereitung der Entwicklungsumgebung](#udf-create-install-sdk-prep-environment) 1. [Erstellen Ihres Maven-Projekts](#create-maven-project) 1. [Hinzufügen von Abhängigkeiten und Plugins zu Ihrem Maven-Projekt](#udf-add-maven-dependencies) 1. [Schreiben Sie Java-Code für UDFs](#udf-write-java) 1. [Erstellen der JAR-Datei](#udf-create-package-jar) 1. [Stellen Sie das JAR bereit für AWS Lambda](#udf-create-deploy) ## Klonen des SDK und Vorbereitung der Entwicklungsumgebung Bevor Sie beginnen, stellen Sie mithilfe von `sudo yum install git -y` sicher, dass git auf Ihrem System installiert ist. **AWS Um das Query Federation SDK zu installieren** + Geben Sie Folgendes in der Befehlszeile ein, um das SDK-Repository zu klonen. Dieses Repository enthält den SDK, Beispiele und eine Suite von Datenquellen-Connectors. Weitere Hinweise zu Datenquellen-Connectors finden Sie unter [Nutzung von Amazon-Athena-Verbundabfrage](federated-queries.md). ``` git clone https://github.com/awslabs/aws-athena-query-federation.git ``` **So installieren Sie die Voraussetzungen für dieses Verfahren:** Wenn Sie auf einem Entwicklungscomputer arbeiten, auf dem Apache Maven AWS CLI, The und das AWS Serverless Application Model Build-Tool bereits installiert sind, können Sie diesen Schritt überspringen. 1. Führen Sie im `aws-athena-query-federation`-Stammverzeichnis des Verzeichnisses, das Sie beim Klonen erstellt haben, das Skript [prepare\$1dev\$1env.sh](https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/prepare_dev_env.sh) aus, das die Entwicklungsumgebung vorbereitet. 1. Aktualisieren Sie die Shell, um neue Variablen zu erzeugen, die durch den Installationsprozess erstellt wurden, oder starten Sie die Terminalsitzung neu. ``` source ~/.profile ``` **Wichtig** Wenn Sie diesen Schritt überspringen, erhalten Sie später eine Fehlermeldung, dass das AWS CLI oder AWS SAM Build-Tool Ihre Lambda-Funktion nicht veröffentlichen kann. ## Erstellen Ihres Maven-Projekts Führen Sie den folgenden Befehl aus, um Ihr Maven-Projekt zu erstellen. *groupId*Ersetzen Sie es durch die eindeutige ID Ihrer Organisation und *my-athena-udf* ersetzen Sie es durch den Namen Ihrer Anwendung. Weitere Informationen finden Sie unter [Wie erstelle ich mein erstes Maven-Projekt](https://maven.apache.org/guides/getting-started/index.html#How_do_I_make_my_first_Maven_project)? in der Apache Maven-Dokumentation. ``` mvn -B archetype:generate \ -DarchetypeGroupId=org.apache.maven.archetypes \ -DgroupId=groupId \ -DartifactId=my-athena-udfs ``` ## Hinzufügen von Abhängigkeiten und Plugins zu Ihrem Maven-Projekt Fügen Sie die folgenden Konfigurationen zu Ihrer Maven-`pom.xml`-Projektdatei hinzu. Ein Beispiel finden Sie in GitHub der Datei [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/pom.xml) unter. ``` 2022.47.1 com.amazonaws aws-athena-federation-sdk ${aws-athena-federation-sdk.version} org.apache.maven.plugins maven-shade-plugin 3.2.1 false *:* META-INF/*.SF META-INF/*.DSA META-INF/*.RSA package shade ``` ## Schreiben Sie Java-Code für UDFs Erstellen Sie eine neue Klasse, indem Sie [UserDefinedFunctionHandler.java erweitern.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java) Schreiben Sie Ihr UDFs Inneres in die Klasse. Im folgenden Beispiel werden zwei Java-Methoden für UDFs, `compress()` und`decompress()`, innerhalb der Klasse erstellt`MyUserDefinedFunctions`. ``` *package *com.mycompany.athena.udfs; public class MyUserDefinedFunctions extends UserDefinedFunctionHandler { private static final String SOURCE_TYPE = "MyCompany"; public MyUserDefinedFunctions() { super(SOURCE_TYPE); } /** * Compresses a valid UTF-8 String using the zlib compression library. * Encodes bytes with Base64 encoding scheme. * * @param input the String to be compressed * @return the compressed String */ public String compress(String input) { byte[] inputBytes = input.getBytes(StandardCharsets.UTF_8); // create compressor Deflater compressor = new Deflater(); compressor.setInput(inputBytes); compressor.finish(); // compress bytes to output stream byte[] buffer = new byte[4096]; ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(inputBytes.length); while (!compressor.finished()) { int bytes = compressor.deflate(buffer); byteArrayOutputStream.write(buffer, 0, bytes); } try { byteArrayOutputStream.close(); } catch (IOException e) { throw new RuntimeException("Failed to close ByteArrayOutputStream", e); } // return encoded string byte[] compressedBytes = byteArrayOutputStream.toByteArray(); return Base64.getEncoder().encodeToString(compressedBytes); } /** * Decompresses a valid String that has been compressed using the zlib compression library. * Decodes bytes with Base64 decoding scheme. * * @param input the String to be decompressed * @return the decompressed String */ public String decompress(String input) { byte[] inputBytes = Base64.getDecoder().decode((input)); // create decompressor Inflater decompressor = new Inflater(); decompressor.setInput(inputBytes, 0, inputBytes.length); // decompress bytes to output stream byte[] buffer = new byte[4096]; ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(inputBytes.length); try { while (!decompressor.finished()) { int bytes = decompressor.inflate(buffer); if (bytes == 0 && decompressor.needsInput()) { throw new DataFormatException("Input is truncated"); } byteArrayOutputStream.write(buffer, 0, bytes); } } catch (DataFormatException e) { throw new RuntimeException("Failed to decompress string", e); } try { byteArrayOutputStream.close(); } catch (IOException e) { throw new RuntimeException("Failed to close ByteArrayOutputStream", e); } // return decoded string byte[] decompressedBytes = byteArrayOutputStream.toByteArray(); return new String(decompressedBytes, StandardCharsets.UTF_8); } } ``` ## Erstellen der JAR-Datei Führen Sie `mvn clean install` aus um Ihr Projekt zu erstellen. Nach erfolgreicher Erstellung wird eine JAR-Datei in dem `target` Ordner Ihres Projekts mit dem Namen erstellt. Dabei *artifactId* handelt es sich beispielsweise um den Namen`artifactId-version.jar`, den Sie im Maven-Projekt angegeben haben. `my-athena-udfs` ## Stellen Sie das JAR bereit für AWS Lambda Sie haben zwei Möglichkeiten, Ihren Code in Lambda bereitzustellen: + Bereitstellen mit AWS Serverless Application Repository (empfohlen) + Erstellen einer Lambda-Funktion aus der JAR-Datei ### Option 1: Bereitstellen auf dem AWS Serverless Application Repository Wenn Sie Ihre JAR-Datei auf dem bereitstellen AWS Serverless Application Repository, erstellen Sie eine AWS SAM YAML-Vorlagendatei, die die Architektur Ihrer Anwendung darstellt. Anschließend geben Sie diese YAML-Datei und einen Amazon-S3-Bucket an, in den Artefakte für Ihre Anwendung hochgeladen und für AWS Serverless Application Repository verfügbar gemacht werden. Im folgenden Verfahren wird das Skript [publish.sh](https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/publish.sh) verwendet, das sich im `athena-query-federation/tools`-Verzeichnis des Athena-Query-Federation-SDKs befindet, das Sie zuvor geklont haben. Weitere Informationen und Anforderungen finden Sie unter [Veröffentlichen von Anwendungen](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-publishing-applications.html) im *AWS Serverless Application Repository Entwicklerhandbuch*, [AWS SAM Vorlagenkonzepte](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) im *AWS Serverless Application Model Entwicklerhandbuch* und [Veröffentlichen serverloser Anwendungen mit der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html). Das folgende Beispiel veranschaulicht Parameter in einer YAML-Datei. Fügen Sie Ihrer YAML-Datei ähnliche Parameter hinzu und speichern Sie diese in Ihrem Projektverzeichnis. Ein vollständiges [Beispiel finden Sie unter athena-udf.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/athena-udfs.yaml). GitHub ``` Transform: 'AWS::Serverless-2016-10-31' Metadata: 'AWS::ServerlessRepo::Application': Name: MyApplicationName Description: 'The description I write for my application' Author: 'Author Name' Labels: - athena-federation SemanticVersion: 1.0.0 Parameters: LambdaFunctionName: Description: 'The name of the Lambda function that will contain your UDFs.' Type: String LambdaTimeout: Description: 'Maximum Lambda invocation runtime in seconds. (min 1 - 900 max)' Default: 900 Type: Number LambdaMemory: Description: 'Lambda memory in MB (min 128 - 3008 max).' Default: 3008 Type: Number Resources: ConnectorConfig: Type: 'AWS::Serverless::Function' Properties: FunctionName: !Ref LambdaFunctionName Handler: "full.path.to.your.handler. For example, com.amazonaws.athena.connectors.udfs.MyUDFHandler" CodeUri: "Relative path to your JAR file. For example, ./target/athena-udfs-1.0.jar" Description: "My description of the UDFs that this Lambda function enables." Runtime: java8 Timeout: !Ref LambdaTimeout MemorySize: !Ref LambdaMemory ``` Kopieren Sie das `publish.sh`-Skript in das Projektverzeichnis, in dem Sie Ihre YAML-Datei gespeichert haben, und führen Sie den folgenden Befehl aus: ``` ./publish.sh MyS3Location MyYamlFile ``` Zum Beispiel, wenn Ihr Bucket-Speicherort `s3://amzn-s3-demo-bucket/mysarapps/athenaudf` ist und Ihre YAML-Datei unter `my-athena-udfs.yaml` gespeichert wurde: ``` ./publish.sh amzn-s3-demo-bucket/mysarapps/athenaudf my-athena-udfs ``` **So erstellen Sie eine Lambda-Funktion** 1. Öffnen Sie die Lambda-Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), wählen Sie **Create function** und dann **Browse Serverless App Repository** 1. Wählen Sie **Private applications (Private Anwendungen)** aus, suchen Sie Ihre Anwendung in der Liste oder mit Schlüsselwörtern und wählen Sie sie aus. 1. Überprüfen und geben Sie Anwendungsdetails an, und wählen Sie dann **Deploy (Bereitstellen)**. Sie können jetzt die in Ihrer JAR-Datei der Lambda-Funktion definierten Methodennamen wie UDFs in Athena verwenden. ### Option 2: Direktes Erstellen einer Lambda-Funktion Sie können eine Lambda-Funktion auch direkt über die Konsole oder AWS CLI erstellen. Das folgende Beispiel veranschaulicht die Verwendung des Lambda-CLI-Befehls `create-function`. ``` aws lambda create-function \ --function-name MyLambdaFunctionName \ --runtime java8 \ --role arn:aws:iam::1234567890123:role/my_lambda_role \ --handler com.mycompany.athena.udfs.MyUserDefinedFunctions \ --timeout 900 \ --zip-file fileb://./target/my-athena-udfs-1.0-SNAPSHOT.jar ```