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'un 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 dans le SDK est disponible GitHub dans le référentiel awslabs/aws-athena-query-federation/athena -federation-sdk, ainsi que des exemples d'implémentations UDF 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 à partir de la ligne de commande, ainsi qu'un déploiement.

Procédez comme suit pour créer un UDF personnalisé pour Athena à l'aide de Maven

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.

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 ? 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 dans GitHub.

<properties>
    <aws-athena-federation-sdk.version>2022.47.1</aws-athena-federation-sdk.version>
</properties>

<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-athena-federation-sdk</artifactId>
        <version>${aws-athena-federation-sdk.version}</version>
    </dependency>
</dependencies>
    
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.2.1</version>
            <configuration>
                <createDependencyReducedPom>false</createDependencyReducedPom>
                <filters>
                    <filter>
                        <artifact>*:*</artifact>
                        <excludes>
                            <exclude>META-INF/*.SF</exclude>
                            <exclude>META-INF/*.DSA</exclude>
                            <exclude>META-INF/*.RSA</exclude>
                        </excludes>
                    </filter>
                </filters>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Écrivez du code Java pour UDFs

Créez une nouvelle classe en étendant le UserDefinedFunctionHandlerfichier .java. Écrivez votre UDFs intérieur dans la classe.

Dans l'exemple suivant, deux méthodes Java pour UDFs, compress() etdecompress(), sont créées dans la classeMyUserDefinedFunctions.

*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 :

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 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 dans le Guide du AWS Serverless Application Repository développeur, concepts de AWS SAM modèles dans le Guide du AWS Serverless Application Model développeur et Publication d'applications sans serveur à l'aide de la AWS SAM CLI.

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

Option 2 : créer directement 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