Crea e distribuisci una UDF usando Lambda

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per creare una funzione definita dall'utente personalizzata, crea una nuova classe Java estendendo la classe UserDefinedFunctionHandler. Il codice sorgente del UserDefinedFunctionHandlerfile.java nell'SDK è disponibile nell'archivio awslabs/aws-athena-query-federation/athena -federation-sdk, insieme GitHub a esempi di implementazioni UDF che puoi esaminare e modificare per creare una UDF personalizzata.

La procedura in questa sezione illustra la scrittura e la creazione di un file Jar della funzione definita dall'utente personalizzata utilizzando Apache Maven dalla riga di comando e una distribuzione.

Esegui i seguenti passaggi per creare una UDF personalizzata per Athena utilizzando Maven

Duplicazione dell'SDK e preparazione dell'ambiente di sviluppo

Prima di iniziare, assicurati che git sia installato sul tuo sistema utilizzando sudo yum install git -y.

Creazione del progetto Maven

Esegui il comando seguente per creare il progetto Maven. Sostituiscila groupId con l'ID univoco della tua organizzazione e my-athena-udf sostituiscila con il nome dell'applicazione. Per ulteriori informazioni, vedi Come faccio a creare il mio primo progetto Maven? nella documentazione di Apache Maven.

mvn -B archetype:generate \
-DarchetypeGroupId=org.apache.maven.archetypes \
-DgroupId=groupId \
-DartifactId=my-athena-udfs

Aggiunta di dipendenze e plugin al progetto Maven

Aggiungi le seguenti configurazioni al file pom.xml del progetto Maven. Per un esempio, consultate il file pom.xml in. 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>

Scrivere codice Java per UDFs

Crea una nuova classe estendendo UserDefinedFunctionHandler.java. Scrivi i tuoi dati UDFs all'interno della classe.

Nell'esempio seguente, all'interno della classe vengono creati due metodi Java per UDFs compress() e decompress()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);
    }
}

Compilazione del file JAR

Esegui mvn clean install per compilare il progetto. Una volta completato correttamente, viene creato un file JAR nella target cartella denominata del progettoartifactId-version.jar, dove si artifactId trova il nome fornito nel progetto Maven, ad esempio. my-athena-udfs

Distribuisci il JAR in AWS Lambda

Hai a disposizione due opzioni per distribuire il codice in Lambda:

Opzione 1: eseguire la distribuzione su AWS Serverless Application Repository

Quando si distribuisce il file JAR su AWS Serverless Application Repository, si crea un file YAML AWS SAM modello che rappresenta l'architettura dell'applicazione. Quindi devi specificare questo file YAML e un bucket Amazon S3 in cui gli artefatti dell'applicazione vengono caricati e resi disponibili ad AWS Serverless Application Repository. Nella procedura riportata di seguito viene utilizzato lo script publish.sh che si trova nella directory athena-query-federation/tools dell'SDK di Athena Query Federation clonato in precedenza.

Per ulteriori informazioni e requisiti, consulta Pubblicazione di applicazioni nella AWS Serverless Application Repository Developer Guide, concetti di AWS SAM template nella AWS Serverless Application Model Developer Guide e Pubblicazione di applicazioni serverless utilizzando la AWS SAM CLI.

Nell'esempio seguente vengono illustrati i parametri in un file YAML. Aggiungi parametri simili al file YAML e salvalo nella directory del progetto. Vedi athena-udf.yaml in per un esempio completo. 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

Copia lo script publish.sh nella directory del progetto in cui è stato salvato il file YAML ed esegui il comando seguente:

./publish.sh MyS3Location MyYamlFile

Ad esempio, se la posizione del bucket è s3://amzn-s3-demo-bucket/mysarapps/athenaudf e il file YAML è stato salvato come my-athena-udfs.yaml:

./publish.sh amzn-s3-demo-bucket/mysarapps/athenaudf my-athena-udfs
            

Opzione 2: creare direttamente una funzione Lambda

Puoi anche creare una funzione Lambda direttamente utilizzando la console o. AWS CLI L'esempio seguente illustra l'utilizzo del comando CLI della 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