Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création et déploiement d’une UDF à l’aide de Lambda
Pour créer une UDF personnalisée, vous créez une nouvelle classe Java en étendant la classe `UserDefinedFunctionHandler`. Le code source du [UserDefinedFunctionHandlerfichier .java contenu](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java) dans le SDK est disponible GitHub dans le [référentiel awslabs/aws-athena-query-federation/athena](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk) -federation-sdk, ainsi que des [exemples d'implémentations UDF](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-udfs) que vous pouvez examiner et modifier pour créer un UDF personnalisé.
Les étapes de cette section illustrent l'écriture et la création d'un fichier Jar UDF personnalisé à l'aide d' [Apache Maven](https://maven.apache.org/index.html) à partir de la ligne de commande, ainsi qu'un déploiement.
Exécutez les étapes suivantes pour créer une UDF personnalisée pour Athena à l’aide de Maven :
1. [Cloner le kit SDK et préparer votre environnement de développement](#udf-create-install-sdk-prep-environment)
1. [Créez votre projet Maven](#create-maven-project)
1. [Ajouter des dépendances et des plugins à votre projet Maven](#udf-add-maven-dependencies)
1. [Écrivez du code Java pour UDFs](#udf-write-java)
1. [Construire le fichier JAR](#udf-create-package-jar)
1. [Déployez le fichier JAR sur AWS Lambda](#udf-create-deploy)
## Cloner le kit SDK et préparer votre environnement de développement
Avant de commencer, assurez-vous que git est installé sur votre système en utilisant `sudo yum install git -y`.
**Pour installer le SDK de fédération de AWS requêtes**
+ Saisissez ce qui suit sur la ligne de commande pour cloner le référentiel SDK. Ce référentiel inclut le kit SDK, des exemples et une suite de connecteurs de source de données. Pour de plus amples informations sur les connecteurs de source de données, veuillez consulter [Utilisation de la requête fédérée Amazon Athena](federated-queries.md).
```
git clone https://github.com/awslabs/aws-athena-query-federation.git
```
**Pour installer les éléments requis pour cette procédure**
Si vous travaillez sur une machine de développement sur laquelle Apache Maven, le AWS CLI, et l'outil de AWS Serverless Application Model compilation sont déjà installés, vous pouvez ignorer cette étape.
1. À partir de la racine du répertoire `aws-athena-query-federation` que vous avez créé lors du clonage, exécutez le script [prepare\$1dev\$1env.sh](https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/prepare_dev_env.sh) qui prépare votre environnement de développement.
1. Mettez à jour votre shell pour obtenir les nouvelles variables créées par le processus d'installation ou redémarrez votre session de terminal.
```
source ~/.profile
```
**Important**
Si vous ignorez cette étape, vous recevrez ultérieurement des erreurs indiquant que l'outil AWS CLI ou l'outil de AWS SAM génération ne sera pas en mesure de publier votre fonction Lambda.
## Créez votre projet Maven
Exécutez la commande suivante pour créer votre projet Maven. Remplacez *groupId* par l'identifiant unique de votre organisation et remplacez *my-athena-udf* par le nom de votre application. Pour plus d'informations, voir [Comment créer mon premier projet Maven](https://maven.apache.org/guides/getting-started/index.html#How_do_I_make_my_first_Maven_project) ? dans la documentation d'Apache Maven.
```
mvn -B archetype:generate \
-DarchetypeGroupId=org.apache.maven.archetypes \
-DgroupId=groupId \
-DartifactId=my-athena-udfs
```
## Ajouter des dépendances et des plugins à votre projet Maven
Ajoutez les configurations suivantes au fichier `pom.xml` du projet Maven. Pour un exemple, consultez le fichier [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/pom.xml) dans GitHub.
```
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
```
## Écrivez du code Java pour UDFs
Créez une nouvelle classe en étendant le [UserDefinedFunctionHandlerfichier .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) Écrivez votre UDFs intérieur dans la classe.
Dans l'exemple suivant, deux méthodes Java pour UDFs, `compress()` et`decompress()`, sont créées dans la classe`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);
}
}
```
## Construire le fichier JAR
Exécutez `mvn clean install` pour construire votre projet. Une fois la compilation réussie, un fichier JAR est créé dans le `target` dossier de votre projet nommé`artifactId-version.jar`, où *artifactId* est le nom que vous avez fourni dans le projet Maven, par exemple,`my-athena-udfs`.
## Déployez le fichier JAR sur AWS Lambda
Vous avez deux options pour déployer votre code sur Lambda :
+ Déployer à l'aide de AWS Serverless Application Repository (recommandé)
+ Création d'une fonction Lambda à partir du fichier JAR
### Option 1 : Déployer sur AWS Serverless Application Repository
Lorsque vous déployez votre fichier JAR sur le AWS Serverless Application Repository, vous créez un AWS SAM modèle de fichier YAML qui représente l'architecture de votre application. Vous spécifiez ensuite ce fichier YAML et un compartiment Simple Storage Service (Amazon S3) où les artefacts de votre application sont téléchargés et mis à disposition du AWS Serverless Application Repository. La procédure ci-dessous utilise le script [publish.sh](https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/publish.sh) situé dans le répertoire `athena-query-federation/tools` du kit Athena Query Federation SDK que vous avez cloné précédemment.
Pour plus d'informations et pour connaître les exigences, consultez [les sections Publication d'applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-publishing-applications.html) dans le *Guide du AWS Serverless Application Repository développeur*, [concepts de AWS SAM modèles](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) dans le *Guide du AWS Serverless Application Model développeur* et [Publication d'applications sans serveur à l'aide de la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html).
L'exemple suivant illustre les paramètres d'un fichier YAML. Ajoutez des paramètres similaires à votre fichier YAML et enregistrez-le dans votre répertoire de projet. Voir [athena-udf.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/athena-udfs.yaml) pour un exemple complet. 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
```
Copiez le script `publish.sh` dans le répertoire du projet dans lequel vous avez enregistré votre fichier YAML et exécutez la commande suivante :
```
./publish.sh MyS3Location MyYamlFile
```
Par exemple, si l'emplacement de votre compartiment est `s3://amzn-s3-demo-bucket/mysarapps/athenaudf` et que votre fichier YAML a été enregistré sous la forme `my-athena-udfs.yaml` :
```
./publish.sh amzn-s3-demo-bucket/mysarapps/athenaudf my-athena-udfs
```
**Pour créer une fonction Lambda**
1. Ouvrez la console Lambda à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), choisissez **Create function**, puis choisissez **Parcourir le référentiel d'applications sans serveur**
1. Choisissez **Private applications** (Applications privées), recherchez votre application dans la liste ou recherchez-la en utilisant des mots clés, puis sélectionnez-la.
1. Vérifiez et fournissez les détails de l'application, puis choisissez **Déployer**.
Vous pouvez désormais utiliser les noms de méthodes définis dans le fichier JAR de votre fonction Lambda comme dans UDFs Athena.
### Option 2 : Création directe d’une fonction Lambda
Vous pouvez également créer une fonction Lambda directement à l'aide de la console ou. AWS CLI L'exemple suivant illustre l'utilisation de la commande CLI `create-function` Lambda.
```
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
```