Configuración de Metastore - Amazon EMR
Uso de AWS Glue Data Catalog como metastoreUso de un metaalmacén de Hive externo

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Configuración de Metastore

Un metaalmacén de Hive es una ubicación centralizada que almacena información estructural sobre las tablas, incluidos los esquemas, los nombres de las particiones y los tipos de datos. Con EMR Serverless, puedes conservar los metadatos de esta tabla en un metaalmacén que tenga acceso a tus trabajos.

Tienes dos opciones para crear un metaalmacén de Hive:

  • La AWS Catálogo de datos de Glue

  • Un metaalmacén externo de Apache Hive

Uso de AWS Glue Data Catalog como metastore

Puedes configurar tus trabajos de Spark y Hive para usar el AWS Glue Data Catalog es su metatienda. Recomendamos esta configuración cuando necesite un metaalmacén persistente o compartido por diferentes aplicaciones, servicios o Cuentas de AWS. Para obtener más información sobre el catálogo de datos, consulte Rellenar el AWS Catálogo de datos de Glue. Para obtener más información AWS Precios de Glue, consulte AWS Precios de Glue.

Puede configurar su trabajo EMR sin servidor para usar el AWS Glue Data Catalog en el mismo Cuenta de AWS como su aplicación o en una diferente Cuenta de AWS.

Configure el AWS Catálogo de datos de Glue

Para configurar el catálogo de datos, elija el tipo de aplicación EMR sin servidor que desee utilizar.

Spark

Cuando usas EMR Studio para ejecutar tus trabajos con aplicaciones Spark EMR sin servidor, el AWS Glue Data Catalog es el metabastore predeterminado.

Cuando usas SDKs o AWS CLI, puede establecer la spark.hadoop.hive.metastore.client.factory.class configuración com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory en los sparkSubmit parámetros de la ejecución de su trabajo. El siguiente ejemplo muestra cómo configurar el catálogo de datos con AWS CLI.

aws emr-serverless start-job-run \
    --application-id application-id \
    --execution-role-arn job-role-arn \
    --job-driver '{
        "sparkSubmit": {
            "entryPoint": "s3://DOC-EXAMPLE-BUCKET/code/pyspark/extreme_weather.py",
            "sparkSubmitParameters": "--conf spark.hadoop.hive.metastore.client.factory.class=com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory --conf spark.driver.cores=1 --conf spark.driver.memory=3g --conf spark.executor.cores=4 --conf spark.executor.memory=3g"
        }
    }'

Como alternativa, puedes establecer esta configuración al crear una nueva SparkSession en tu código de Spark.

from pyspark.sql import SparkSession

spark = (
    SparkSession.builder.appName("SparkSQL")
    .config(
        "spark.hadoop.hive.metastore.client.factory.class",
        "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory",
    )
    .enableHiveSupport()
    .getOrCreate()
)

# we can query tables with SparkSQL
spark.sql("SHOW TABLES").show()

# we can also them with native Spark
print(spark.catalog.listTables())
Hive

En el EMR caso de las aplicaciones Hive sin servidor, el catálogo de datos es el metabastore predeterminado. Es decir, cuando se ejecutan trabajos en una aplicación Hive EMR sin servidor, Hive registra la información del metaalmacén del catálogo de datos en la misma Cuenta de AWS como su aplicación. No necesita una nube privada virtual (VPC) para usar el catálogo de datos como metaalmacén.

Para acceder a las tablas del metaalmacén de Hive, añada las tablas necesarias AWS Las políticas de Glue se describen en Configuración de IAM permisos para AWS Glue.

Configure el acceso multicuenta para EMR Serverless y AWS Catálogo de datos de Glue

Para configurar el acceso multicuenta para EMR Serverless, primero debe iniciar sesión en lo siguiente Cuentas de AWS:

  • AccountA— Un Cuenta de AWS donde ha creado una aplicación EMR sin servidor.

  • AccountB— Un Cuenta de AWS que contiene un AWS Glue Data Catalog al que desea que acceda su trabajo EMR sin servidor.

  1. Asegúrese de que un administrador u otra identidad autorizada AccountB adjunte una política de recursos al catálogo de datos en. AccountB Esta política otorga permisos AccountA específicos entre cuentas para realizar operaciones con los recursos del AccountB catálogo.

    {
  "Version" : "2012-10-17",
  "Statement" : [ {
    "Effect" : "Allow",
    "Principal": {
        "AWS": [
            "arn:aws:iam::accountA:role/job-runtime-role-A"
        ]},
    "Action" : [
        "glue:GetDatabase",
        "glue:CreateDatabase",
        "glue:GetDataBases",
        "glue:CreateTable",
        "glue:GetTable",
        "glue:UpdateTable",
        "glue:DeleteTable",
        "glue:GetTables",
        "glue:GetPartition",
        "glue:GetPartitions",
        "glue:CreatePartition",
        "glue:BatchCreatePartition",
        "glue:GetUserDefinedFunctions"
    ],
    "Resource": ["arn:aws:glue:region:AccountB:catalog"]
  } ]
}

  2. Agregue una IAM política a la función EMR Serverless Job Runtime AccountA para que esa función pueda acceder a los recursos del catálogo de datos. AccountB

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "glue:GetDatabase",
        "glue:CreateDatabase",
        "glue:GetDataBases",
        "glue:CreateTable",
        "glue:GetTable",
        "glue:UpdateTable",
        "glue:DeleteTable",
        "glue:GetTables",
        "glue:GetPartition",
        "glue:GetPartitions",
        "glue:CreatePartition",
        "glue:BatchCreatePartition",
        "glue:GetUserDefinedFunctions"
      ],
      "Resource": ["arn:aws:glue:region:AccountB:catalog"]
    }
  ]
}

  3. Inicie la ejecución de su trabajo. Este paso es ligeramente diferente según el tipo AccountA de aplicación EMR sin servidor.

    Spark

    Defina la spark.hadoop.hive.metastore.glue.catalogid propiedad en la hive-site clasificación, tal y como se muestra en el siguiente ejemplo. Reemplazar ID de catálogo de la cuenta con el ID del catálogo de datos en. AccountB

    aws emr-serverless start-job-run \
--application-id "application-id" \
--execution-role-arn "job-role-arn" \
--job-driver '{
    "sparkSubmit": {
        "query": "s3://DOC-EXAMPLE-BUCKET/hive/scripts/create_table.sql",
        "parameters": "--hiveconf hive.exec.scratchdir=s3://DOC-EXAMPLE-BUCKET/hive/scratch --hiveconf hive.metastore.warehouse.dir=s3://DOC-EXAMPLE-BUCKET/hive/warehouse"
    }
  }' \
--configuration-overrides '{
    "applicationConfiguration": [{
        "classification": "hive-site",
        "properties": {
            "spark.hadoop.hive.metastore.glue.catalogid": "AccountB-catalog-id"
        }
    }]
}'
    Hive

    Defina la hive.metastore.glue.catalogid propiedad en la hive-site clasificación, tal y como se muestra en el siguiente ejemplo. Reemplazar ID de catálogo de la cuenta con el ID del catálogo de datos en. AccountB

    aws emr-serverless start-job-run \
--application-id "application-id" \
--execution-role-arn "job-role-arn" \
--job-driver '{
    "hive": {
    "query": "s3://DOC-EXAMPLE-BUCKET/hive/scripts/create_table.sql",
    "parameters": "--hiveconf hive.exec.scratchdir=s3://DOC-EXAMPLE-BUCKET/hive/scratch --hiveconf hive.metastore.warehouse.dir=s3://DOC-EXAMPLE-BUCKET/hive/warehouse"
    }
}' \
--configuration-overrides '{
    "applicationConfiguration": [{
        "classification": "hive-site",
        "properties": {
            "hive.metastore.glue.catalogid": "AccountB-catalog-id"
        }
    }]
}'

Consideraciones a la hora de utilizar el AWS Catálogo de datos de Glue

Puede añadir un elemento auxiliar JARs ADD JAR en sus scripts de Hive. Para obtener información adicional, consulte Consideraciones a la hora de utilizar AWS Catálogo de datos de Glue.

Uso de un metaalmacén de Hive externo

Puede configurar sus trabajos de Spark y Hive EMR sin servidor para que se conecten a un metaalmacén de Hive externo, como Amazon Aurora o Amazon for My. RDS SQL En esta sección, se describe cómo configurar un metaalmacén de Amazon RDS Hive, configurar sus VPC trabajos EMR sin servidor y configurarlos para que usen un metaalmacén externo.

Cree un metastore de Hive externo

  1. Cree una Amazon Virtual Private Cloud (AmazonVPC) con subredes privadas siguiendo las instrucciones de Create a VPC.

  2. Cree su aplicación EMR sin servidor con sus nuevas subredes de Amazon VPC y privadas. Cuando configura su aplicación EMR sin servidor con unVPC, primero aprovisiona una interfaz de red elástica para cada subred que especifique. A continuación, conecta el grupo de seguridad especificado a esa interfaz de red. Esto le da a la aplicación el control de acceso. Para obtener más información sobre cómo configurar suVPC, consulteConfigurar VPC el acceso.

  3. Cree una SQL base de datos My SQL o Aurora Postgre en una subred privada de Amazon. VPC Para obtener información sobre cómo crear una RDS base de datos de Amazon, consulte Creación de una RDS instancia de base de datos de Amazon.

  4. Modifique el grupo de seguridad de su base de datos My SQL o Aurora para permitir JDBC las conexiones desde su grupo de seguridad EMR sin servidor siguiendo los pasos que se indican en Modificación de una RDS instancia de base de datos de Amazon. Añada una regla para el tráfico entrante al grupo de RDS seguridad desde uno de sus grupos de seguridad EMR sin servidor.

    Tipo Protocolo Intervalo de puertos Origen

    Todos TCP

    TCP

    3306

    emr-serverless-security-group

Configura las opciones de Spark

Usando JDBC

Para configurar su aplicación Spark EMR sin servidor para que se conecte a un metaalmacén de Hive basado en una SQL instancia Amazon RDS for My o Amazon SQL Aurora My, utilice una conexión. JDBC Introduce mariadb-connector-java.jar los spark-submit parámetros de --jars la ejecución de tu trabajo.

aws emr-serverless start-job-run \
  --application-id "application-id" \
  --execution-role-arn "job-role-arn" \
  --job-driver '{
        "sparkSubmit": {
            "entryPoint": "s3://DOC-EXAMPLE-BUCKET/scripts/spark-jdbc.py",
            "sparkSubmitParameters": "--jars s3://DOC-EXAMPLE-BUCKET/mariadb-connector-java.jar 
            --conf spark.hadoop.javax.jdo.option.ConnectionDriverName=org.mariadb.jdbc.Driver 
            --conf spark.hadoop.javax.jdo.option.ConnectionUserName=<connection-user-name> 
            --conf spark.hadoop.javax.jdo.option.ConnectionPassword=<connection-password>
            --conf spark.hadoop.javax.jdo.option.ConnectionURL=<JDBC-Connection-string> 
            --conf spark.driver.cores=2
            --conf spark.executor.memory=10G 
            --conf spark.driver.memory=6G 
            --conf spark.executor.cores=4"
        }
    }' \
    --configuration-overrides '{
        "monitoringConfiguration": {
        "s3MonitoringConfiguration": {
            "logUri": "s3://DOC-EXAMPLE-BUCKET/spark/logs/"
        }
    }
}'

El siguiente ejemplo de código es un script de punto de entrada de Spark que interactúa con una metatienda de Hive en Amazon. RDS

from os.path import expanduser, join, abspath
from pyspark.sql import SparkSession
from pyspark.sql import Row
# warehouse_location points to the default location for managed databases and tables
warehouse_location = abspath('spark-warehouse')
spark = SparkSession \
    .builder \
    .config("spark.sql.warehouse.dir", warehouse_location) \
    .enableHiveSupport() \
    .getOrCreate()
spark.sql("SHOW DATABASES").show()
spark.sql("CREATE EXTERNAL TABLE `sampledb`.`sparknyctaxi`(`dispatching_base_num` string, `pickup_datetime` string, `dropoff_datetime` string, `pulocationid` bigint, `dolocationid` bigint, `sr_flag` bigint) STORED AS PARQUET LOCATION 's3://<s3 prefix>/nyctaxi_parquet/'")
spark.sql("SELECT count(*) FROM sampledb.sparknyctaxi").show()
spark.stop()

¿Utilizas el servicio de segunda mano

Puede configurar su aplicación Hive EMR sin servidor para que se conecte a un metaalmacén de Hive basado en una instancia Amazon RDS for My o Amazon SQL Aurora My. SQL Para ello, ejecute un servidor de segunda mano en el nodo principal de un EMR clúster de Amazon existente. Esta opción es ideal si ya tiene un EMR clúster de Amazon con un servidor de segunda mano que desea utilizar para simplificar las configuraciones de sus trabajos EMR sin servidor. 

aws emr-serverless start-job-run \
  --application-id "application-id" \
  --execution-role-arn "job-role-arn" \
  --job-driver '{
        "sparkSubmit": {
            "entryPoint": "s3://DOC-EXAMPLE-BUCKET/thriftscript.py",
            "sparkSubmitParameters": "--jars s3://DOC-EXAMPLE-BUCKET/mariadb-connector-java.jar 
            --conf spark.driver.cores=2
            --conf spark.executor.memory=10G 
            --conf spark.driver.memory=6G 
            --conf spark.executor.cores=4"
        }
    }' \
    --configuration-overrides '{
        "monitoringConfiguration": {
        "s3MonitoringConfiguration": {
            "logUri": "s3://DOC-EXAMPLE-BUCKET/spark/logs/"
        }
    }
}'

El siguiente ejemplo de código es un script de punto de entrada (thriftscript.py) que usa el protocolo thrift para conectarse a un metaalmacén de Hive. Tenga en cuenta que la hive.metastore.uris propiedad debe configurarse para que se lea desde un metaalmacén de Hive externo. 

from os.path import expanduser, join, abspath
from pyspark.sql import SparkSession
from pyspark.sql import Row
# warehouse_location points to the default location for managed databases and tables
warehouse_location = abspath('spark-warehouse')
spark = SparkSession \
    .builder \
    .config("spark.sql.warehouse.dir", warehouse_location) \
    .config("hive.metastore.uris","thrift://thrift-server-host:thift-server-port") \
    .enableHiveSupport() \
    .getOrCreate()
spark.sql("SHOW DATABASES").show()
spark.sql("CREATE EXTERNAL TABLE sampledb.`sparknyctaxi`( `dispatching_base_num` string, `pickup_datetime` string, `dropoff_datetime` string, `pulocationid` bigint, `dolocationid` bigint, `sr_flag` bigint) STORED AS PARQUET LOCATION 's3://<s3 prefix>/nyctaxi_parquet/'")
spark.sql("SELECT * FROM sampledb.sparknyctaxi").show()
spark.stop()

Configure las opciones de Hive

Usando JDBC

Si desea especificar una ubicación de base de datos de Hive externa en una instancia de Amazon RDS My SQL o Amazon Aurora, puede anular la configuración predeterminada del metaalmacén.

nota

En Hive, puede realizar varias escrituras en tablas de metaalmacenes al mismo tiempo. Si compartes la información del metaalmacén entre dos trabajos, asegúrate de no escribir en la misma tabla de metastore simultáneamente, a menos que escribas en particiones diferentes de la misma tabla de metastore.

Defina las siguientes configuraciones en la hive-site clasificación para activar el metaalmacén externo de Hive. 

{
    "classification": "hive-site",
    "properties": {
        "hive.metastore.client.factory.class": "org.apache.hadoop.hive.ql.metadata.SessionHiveMetaStoreClientFactory",
        "javax.jdo.option.ConnectionDriverName": "org.mariadb.jdbc.Driver",
        "javax.jdo.option.ConnectionURL": "jdbc:mysql://db-host:db-port/db-name",
        "javax.jdo.option.ConnectionUserName": "username",
        "javax.jdo.option.ConnectionPassword": "password"
    }
}

Uso de un servidor de segunda mano

Puede configurar su aplicación Hive EMR sin servidor para que se conecte a un metaalmacén de Hive basado en Amazon RDS for My o Amazon SQL Aurora M. ySQLinstance Para ello, ejecuta un servidor de segunda mano en el nodo principal de un EMR clúster de Amazon existente. Esta opción es ideal si ya tienes un EMR clúster de Amazon que ejecuta un servidor de segunda mano y quieres usar tus configuraciones de trabajo EMR sin servidor.

Defina las siguientes configuraciones en la hive-site clasificación para que EMR Serverless pueda acceder al metaalmacén remoto de Thrift. Tenga en cuenta que debe configurar la hive.metastore.uris propiedad para que se lea desde un metaalmacén de Hive externo. 

{
    "classification": "hive-site",
    "properties": {
        "hive.metastore.client.factory.class": "org.apache.hadoop.hive.ql.metadata.SessionHiveMetaStoreClientFactory",
        "hive.metastore.uris": "thrift://thrift-server-host:thirft-server-port"
    }
}

Consideraciones a la hora de utilizar un metaalmacén externo