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

Crea e distribuisci un file UDF con Lambda

Per creare una classe personalizzataUDF, è necessario creare una nuova classe Java estendendo la classe. UserDefinedFunctionHandler Il codice sorgente per il UserDefinedFunctionHandlerfile.java in SDK è disponibile nel athena-federation-sdk repository awslabs/aws-athena-query-federation/, insieme a UDFimplementazioni di esempio che puoi esaminare e modificare per crearne una personalizzata. GitHub UDF

I passaggi di questa sezione dimostrano la scrittura e la creazione di un file UDF Jar personalizzato utilizzando Apache Maven dalla riga di comando e da una distribuzione.

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

Clona e prepara il tuo ambiente di SDK 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. Replace (Sostituisci) groupId con l'ID univoco della tua organizzazione e sostituisci my-athena-udf con il nome della tua applicazione Per ulteriori informazioni, vedi Come faccio a realizzare 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);
    }
}

Create il JAR file

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

Distribuisci il JAR 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 JAR file su AWS Serverless Application Repository, si crea un YAML file AWS SAM modello che rappresenta l'architettura dell'applicazione. Quindi specifica questo YAML file e un bucket Amazon S3 in cui gli artefatti per la tua applicazione vengono caricati e resi disponibili per. AWS Serverless Application Repository La procedura seguente utilizza lo script publish.sh che si trova nella athena-query-federation/tools directory di Athena Query Federation SDK che hai clonato in precedenza.

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

L'esempio seguente illustra i parametri in un YAML file. Aggiungete parametri simili al YAML file e salvatelo 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 publish.sh script nella directory del progetto in cui hai salvato il YAML file ed esegui il seguente comando:

./publish.sh MyS3Location MyYamlFile

Ad esempio, se la posizione del bucket è s3://amzn-s3-demo-bucket/mysarapps/athenaudf e il YAML file è stato salvato comemy-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 dimostra l'utilizzo del comando create-function CLI 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