Show Menu
TEMAS×

Guías de migración de fórmulas y portátiles

Los equipos portátiles y las fórmulas que utilizan Python/R no se ven afectados. La migración solo se aplica a las fórmulas y los blocs de notas PySpark/Spark (2.3).
Las siguientes guías describen los pasos y la información necesarios para migrar las fórmulas y los blocs de notas existentes.

Guía de migración de Spark

El artefacto de fórmula generado por los pasos de compilación es ahora una imagen de Docker que contiene el archivo binario .jar. Además, la sintaxis utilizada para leer y escribir conjuntos de datos mediante el SDK de plataforma ha cambiado y requiere que modifique el código de fórmula.
El siguiente vídeo está diseñado para ayudar a comprender mejor los cambios que se requieren para las fórmulas de Spark:

Leer y escribir conjuntos de datos (Spark)

Antes de crear la imagen de Docker, revise los ejemplos de lectura y escritura de conjuntos de datos en el SDK de plataforma, que se proporcionan en las secciones siguientes. Si va a convertir las fórmulas existentes, es necesario actualizar el código del SDK de la plataforma.

Leer un conjunto de datos

En esta sección se describen los cambios necesarios para leer un conjunto de datos y se utiliza el ejemplo helper.scala , proporcionado por Adobe.
Forma antigua de leer un conjunto de datos
 var df = sparkSession.read.format("com.adobe.platform.dataset")
    .option(DataSetOptions.orgId, orgId)
    .option(DataSetOptions.serviceToken, serviceToken)
    .option(DataSetOptions.userToken, userToken)
    .option(DataSetOptions.serviceApiKey, apiKey)
    .load(dataSetId)

Nueva forma de leer un conjunto de datos
Con las actualizaciones de las fórmulas de Spark, es necesario agregar y cambiar varios valores. En primer lugar, ya no DataSetOptions se utiliza. Replace DataSetOptions with QSOption . Además, se requieren nuevos option parámetros. Tanto QSOption.mode como QSOption.datasetId son necesarios. Por último, orgId y serviceApiKey hay que cambiarlo por imsOrg y apiKey . Consulte el siguiente ejemplo para ver una comparación sobre la lectura de conjuntos de datos:
import com.adobe.platform.query.QSOption
var df = sparkSession.read.format("com.adobe.platform.query")
  .option(QSOption.userToken", {userToken})
  .option(QSOption.serviceToken, {serviceToken})
  .option(QSOption.imsOrg, {orgId})
  .option(QSOption.apiKey, {apiKey})
  .option(QSOption.mode, "interactive")
  .option(QSOption.datasetId, {dataSetId})
  .load()

El tiempo de espera del modo interactivo finaliza si las consultas se ejecutan más de 10 minutos. Si va a ingerir más de unos cuantos gigabytes de datos, se recomienda cambiar al modo "por lotes". El modo de lotes tarda más en inicio, pero puede manejar conjuntos de datos más grandes.

Escribir en un conjunto de datos

Esta sección describe los cambios necesarios para escribir un conjunto de datos mediante el ejemplo ScoringDataSaver.scala , proporcionado por Adobe.
Forma antigua de escribir un conjunto de datos
df.write.format("com.adobe.platform.dataset")
    .option(DataSetOptions.orgId, orgId)
    .option(DataSetOptions.serviceToken, serviceToken)
    .option(DataSetOptions.userToken, userToken)
    .option(DataSetOptions.serviceApiKey, apiKey)
    .save(scoringResultsDataSetId)

Nueva forma de escribir un conjunto de datos
Con las actualizaciones de las fórmulas de Spark, es necesario agregar y cambiar varios valores. En primer lugar, ya no DataSetOptions se utiliza. Replace DataSetOptions with QSOption . Además, se requieren nuevos option parámetros. QSOption.datasetId y reemplaza la necesidad de cargar el {dataSetId} en .save() . Por último, orgId y serviceApiKey hay que cambiarlo por imsOrg y apiKey . Consulte el siguiente ejemplo para ver una comparación sobre cómo escribir conjuntos de datos:
import com.adobe.platform.query.QSOption
df.write.format("com.adobe.platform.query")
  .option(QSOption.userToken", {userToken})
  .option(QSOption.serviceToken, {serviceToken})
  .option(QSOption.imsOrg, {orgId})
  .option(QSOption.apiKey, {apiKey})
  .option(QSOption.datasetId, {dataSetId})
  .save()

Archivos de origen basados en el acoplador de paquetes (Spark)

Inicio navegando al directorio donde se encuentra la fórmula.
Las siguientes secciones utilizan la nueva fórmula de ventas minoristas de Scala, que se encuentra en el repositorio público Github de Data Science Workspace.

Descargar la fórmula de muestra (Spark)

La fórmula de ejemplo contiene archivos que deben copiarse en la fórmula existente. Para clonar el Github público que contiene todas las fórmulas de muestra, introduzca lo siguiente en el terminal:
git clone https://github.com/adobe/experience-platform-dsw-reference.git

La fórmula Scala se encuentra en el siguiente directorio experience-platform-dsw-reference/recipes/scala/retail .

Añadir el archivo de acoplamiento (Spark)

Se necesita un nuevo archivo en la carpeta de fórmulas para utilizar el flujo de trabajo basado en docker. Copie y pegue el archivo de Dockerfile desde la carpeta de fórmulas ubicada en experience-platform-dsw-reference/recipes/scala/Dockerfile . Opcionalmente, también puede copiar y pegar el código siguiente en un nuevo archivo llamado Dockerfile .
El archivo jar de ejemplo que se muestra a continuación ml-retail-sample-spark-*-jar-with-dependencies.jar debe reemplazarse por el nombre del archivo jar de la fórmula.
FROM adobe/acp-dsw-ml-runtime-spark:0.0.1

COPY target/ml-retail-sample-spark-*-jar-with-dependencies.jar /application.jar

Cambiar dependencias (Spark)

Si está utilizando una fórmula existente, se requieren cambios en el archivo pom.xml para las dependencias. Cambie la versión de dependencia model-authoring-sdk a 2.0.0. A continuación, actualice la versión de Spark en el archivo pom a 2.4.3 y la versión de Scala a a 2.11.12.
<groupId>com.adobe.platform.ml</groupId>
<artifactId>authoring-sdk_2.11</artifactId>
<version>2.0.0</version>
<classifier>jar-with-dependencies</classifier>

Preparación de los scripts del acoplador (Spark)

Las fórmulas de chispa ya no utilizan artefactos binarios y, en su lugar, requieren crear una imagen de acoplamiento. Si no lo ha hecho, descargue e instale Docker .
En la fórmula de muestra de Scala proporcionada, puede encontrar las secuencias de comandos login.sh y build.sh ubicada en experience-platform-dsw-reference/recipes/scala/ . Copie y pegue estos archivos en la fórmula existente.
La estructura de carpetas ahora debe tener un aspecto similar al siguiente ejemplo (los archivos recién agregados se resaltan):
El siguiente paso es seguir los archivos de origen del paquete en un tutorial de fórmula . Este tutorial tiene una sección que describe la creación de una imagen de acoplador para una fórmula Scala (Spark). Una vez completada, se le proporcionará la imagen del Docker en un Registro de Contenedores de Azure junto con la URL de la imagen correspondiente.

Crear una fórmula (Chispa)

Para crear una fórmula, primero debe completar el tutorial de archivos de origen del paquete y tener preparada la URL de la imagen del docker. Puede crear una fórmula con la interfaz de usuario o la API.
Para crear la fórmula con la IU, siga el tutorial Importar una fórmula empaquetada (UI) para Scala.
Para crear la fórmula con la API, siga el tutorial Importar una fórmula empaquetada (API) para Scala.

Guía de migración de PySpark

El artefacto de fórmula generado por los pasos de compilación es ahora una imagen de Docker que contiene el archivo .egg binario. Además, la sintaxis utilizada para leer y escribir conjuntos de datos mediante el SDK de plataforma ha cambiado y requiere que modifique el código de fórmula.
El siguiente vídeo está diseñado para ayudar a comprender mejor los cambios necesarios para las fórmulas de PySpark:

Lectura y escritura de conjuntos de datos (PySpark)

Antes de crear la imagen de Docker, revise los ejemplos de lectura y escritura de conjuntos de datos en el SDK de plataforma, que se proporcionan en las secciones siguientes. Si va a convertir las fórmulas existentes, es necesario actualizar el código del SDK de la plataforma.

Leer un conjunto de datos

Esta sección describe los cambios necesarios para leer un conjunto de datos mediante el ejemplo helper.py , proporcionado por Adobe.
Forma antigua de leer un conjunto de datos
dataset_options = get_dataset_options(spark.sparkContext)
pd = spark.read.format("com.adobe.platform.dataset") 
  .option(dataset_options.serviceToken(), service_token) 
  .option(dataset_options.userToken(), user_token) 
  .option(dataset_options.orgId(), org_id) 
  .option(dataset_options.serviceApiKey(), api_key)
  .load(dataset_id)

Nueva forma de leer un conjunto de datos
Con las actualizaciones de las fórmulas de Spark, es necesario agregar y cambiar varios valores. En primer lugar, ya no DataSetOptions se utiliza. Replace DataSetOptions with qs_option . Además, se requieren nuevos option parámetros. Tanto qs_option.mode como qs_option.datasetId son necesarios. Por último, orgId y serviceApiKey hay que cambiarlo por imsOrg y apiKey . Consulte el siguiente ejemplo para ver una comparación sobre la lectura de conjuntos de datos:
qs_option = spark_context._jvm.com.adobe.platform.query.QSOption
pd = sparkSession.read.format("com.adobe.platform.query") 
  .option(qs_option.userToken, {userToken}) 
  .option(qs_option.serviceToken, {serviceToken}) 
  .option(qs_option.imsOrg, {orgId}) 
  .option(qs_option.apiKey, {apiKey}) 
  .option(qs_option.mode, "interactive") 
  .option(qs_option.datasetId, {dataSetId}) 
  .load()

El tiempo de espera del modo interactivo finaliza si las consultas se ejecutan más de 10 minutos. Si va a ingerir más de unos cuantos gigabytes de datos, se recomienda cambiar al modo "por lotes". El modo de lotes tarda más en inicio, pero puede manejar conjuntos de datos más grandes.

Escribir en un conjunto de datos

Esta sección describe los cambios necesarios para escribir un conjunto de datos mediante el ejemplo data_saver.py , proporcionado por Adobe.
Forma antigua de escribir un conjunto de datos
df.write.format("com.adobe.platform.dataset")
  .option(DataSetOptions.orgId, orgId)
  .option(DataSetOptions.serviceToken, serviceToken)
  .option(DataSetOptions.userToken, userToken)
  .option(DataSetOptions.serviceApiKey, apiKey)
  .save(scoringResultsDataSetId)

Nueva forma de escribir un conjunto de datos
Con las actualizaciones de las fórmulas de PySpark, es necesario agregar y cambiar varios valores. En primer lugar, ya no DataSetOptions se utiliza. Replace DataSetOptions with qs_option . Además, se requieren nuevos option parámetros. qs_option.datasetId y reemplaza la necesidad de cargar el {dataSetId} en .save() . Por último, orgId y serviceApiKey hay que cambiarlo por imsOrg y apiKey . Consulte el siguiente ejemplo para ver una comparación sobre la lectura de conjuntos de datos:
qs_option = spark_context._jvm.com.adobe.platform.query.QSOption
scored_df.write.format("com.adobe.platform.query") 
  .option(qs_option.userToken, {userToken}) 
  .option(qs_option.serviceToken, {serviceToken}) 
  .option(qs_option.imsOrg, {orgId}) 
  .option(qs_option.apiKey, {apiKey}) 
  .option(qs_option.datasetId, {dataSetId}) 
  .save()

Archivos de origen basados en el acoplador de paquetes (PySpark)

Inicio navegando al directorio donde se encuentra la fórmula.
Para este ejemplo, se utiliza la nueva fórmula de ventas minoristas de PySpark y se puede encontrar en el repositorio público de Github de Data Science Workspace.

Descargar la fórmula de muestra (PySpark)

La fórmula de ejemplo contiene archivos que deben copiarse en la fórmula existente. Para clonar el Github público que contiene todas las fórmulas de muestra, introduzca lo siguiente en la terminal.
git clone https://github.com/adobe/experience-platform-dsw-reference.git

La fórmula PySpark se encuentra en el siguiente directorio experience-platform-dsw-reference/recipes/pyspark .

Añadir el archivo de Dockerfile (PySpark)

Se necesita un nuevo archivo en la carpeta de fórmulas para utilizar el flujo de trabajo basado en docker. Copie y pegue el archivo de Dockerfile desde la carpeta de fórmulas ubicada en experience-platform-dsw-reference/recipes/pyspark/Dockerfile . Opcionalmente, también puede copiar y pegar el código siguiente y crear un nuevo archivo llamado Dockerfile .
El archivo de ejemplo de huevo que se muestra a continuación pysparkretailapp-*.egg debe reemplazarse por el nombre del archivo de huevo de la fórmula.
FROM adobe/acp-dsw-ml-runtime-pyspark:0.0.1
RUN mkdir /recipe

COPY . /recipe

RUN cd /recipe && \
    ${PYTHON} setup.py clean install && \
    rm -rf /recipe

RUN cp /databricks/conda/envs/${DEFAULT_DATABRICKS_ROOT_CONDA_ENV}/lib/python3.6/site-packages/pysparkretailapp-*.egg /application.egg

Preparación de los scripts de Docker (PySpark)

Las fórmulas de PySpark ya no utilizan artefactos binarios y, en su lugar, requieren crear una imagen de Docker. Si no lo ha hecho, descargue e instale Docker .
En la fórmula de muestra PySpark proporcionada, puede encontrar los scripts login.sh y build.sh ubicados en experience-platform-dsw-reference/recipes/pyspark . Copie y pegue estos archivos en la fórmula existente.
La estructura de carpetas ahora debe tener un aspecto similar al siguiente ejemplo (los archivos recién agregados se resaltan):
La fórmula ya está lista para crearse con una imagen de Docker. El siguiente paso es seguir los archivos de origen del paquete en un tutorial de fórmula . Este tutorial tiene una sección que describe cómo crear una imagen de acoplador para una fórmula PySpark (Spark 2.4). Una vez completada, se le proporcionará la imagen del Docker en un Registro de Contenedores de Azure junto con la URL de la imagen correspondiente.

Crear una fórmula (PySpark)

Para crear una fórmula, primero debe completar el tutorial de archivos de origen del paquete y tener preparada la URL de la imagen del docker. Puede crear una fórmula con la interfaz de usuario o la API.
Para crear la fórmula con la IU, siga el tutorial Importar una fórmula empaquetada (UI) de PySpark.
Para crear la fórmula con la API, siga el tutorial Importar una fórmula empaquetada (API) de PySpark.

Guías de migración de equipos portátiles

Los cambios recientes en los blocs de notas de JupyterLab requieren que actualice los blocs de notas PySpark y Spark 2.3 existentes a 2.4. Con este cambio, JupyterLab Launcher se ha actualizado con nuevos portátiles de arranque. Para obtener una guía paso a paso sobre cómo convertir los blocs de notas, seleccione una de las siguientes guías:
El siguiente vídeo está diseñado para ayudar a comprender mejor los cambios que se requieren para los equipos portátiles JupyterLab:

Guía de migración de portátiles PySpark 2.3 a 2.4

Con la introducción de PySpark 2.4 a los portátiles JupyterLab, los nuevos portátiles Python con PySpark 2.4 ahora utilizan el núcleo Python 3 en lugar del núcleo PySpark 3. Esto significa que el código existente que se ejecuta en PySpark 2.3 no es compatible con PySpark 2.4.
PySpark 2.3 está en desuso y está configurado para eliminarse en una versión posterior. Todos los ejemplos existentes se han configurado para reemplazarse con ejemplos de PySpark 2.4.
Para convertir los portátiles PySpark 3 (Spark 2.3) existentes a Spark 2.4, siga los ejemplos que se describen a continuación:

Kernel

Los portátiles PySpark 3 (Spark 2.4) utilizan el núcleo Python 3 en lugar del núcleo PySpark desaprobado que se utiliza en los portátiles PySpark 3 (Spark 2.3 - desaprobado).
Para confirmar o cambiar el núcleo en la interfaz de usuario de JupyterLab, seleccione el botón del núcleo ubicado en la barra de navegación superior derecha del bloc de notas. Si está utilizando uno de los blocs de notas predefinidos del iniciador, el núcleo está preseleccionado. El ejemplo siguiente utiliza el motor de arranque del bloc de notas PySpark 3 (Spark 2.4) Aggregation .
Al seleccionar el menú desplegable, se abre una lista de núcleos disponibles.
Para los portátiles PySpark 3 (Spark 2.4), seleccione el núcleo Python 3 y confirme haciendo clic en el botón Seleccionar .

Inicializando sparkSession

Todos los blocs de notas Spark 2.4 requieren que inicialice la sesión con el nuevo código repetitivo.
Portátil PySpark 3 (Spark 2.3, obsoleto) PySpark 3 (Spark 2.4)
Kernel PySpark 3 Python 3
Código
  spark


desde pyspark.sql import SparkSessionspark = SparkSession.builder.getOrCreate()


Las siguientes imágenes resaltan las diferencias en la configuración de PySpark 2.3 y PySpark 2.4. Este ejemplo utiliza los blocs de notas de inicio de Agregación proporcionados en JupyterLab Launcher.
Ejemplo de configuración para 2.3 (desaprobado)
Ejemplo de configuración para 2.4

Uso de la magia %dataset

Con la introducción de Spark 2.4, %dataset la magia personalizada se suministra para su uso en los nuevos portátiles PySpark 3 (Spark 2.4) (núcleo Python 3).
Uso
%dataset {action} --datasetId {id} --dataFrame {df}
Descripción
Un comando mágico personalizado de Data Science Workspace para leer o escribir un conjunto de datos desde un bloc de notas Python (núcleo Python 3).
  • : Tipo de acción que se realizará en el conjunto de datos. Hay dos acciones disponibles: "lectura" o "escritura".
  • —datasetId : Se utiliza para proporcionar la identificación del conjunto de datos que se va a leer o escribir. Este es un argumento requerido.
  • —dataFrame : El juego de datos pandas. Este es un argumento requerido.
    • Cuando la acción es "leída", es la variable donde están disponibles los resultados de la operación de lectura del conjunto de datos.
    • Cuando la acción es "write", este dataframe se escribe en el conjunto de datos.
  • —mode (opcional) : Los parámetros permitidos son "batch" e "interactive". De forma predeterminada, el modo se establece en "interactivo". Se recomienda utilizar el modo "por lotes" al leer grandes cantidades de datos.
Ejemplos
  • Leer ejemplo : %dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0
  • Ejemplo de escritura: %dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0

Cargar en un marco de datos en LocalContext

Con la introducción de Spark 2.4, se proporciona %dataset magia personalizada. El siguiente ejemplo resalta las diferencias clave para cargar el datafame en los blocs de notas PySpark (Spark 2.3) y PySpark (Spark 2.4):
Uso de PySpark 3 (Spark 2.3 - desaprobado) - Núcleo de PySpark 3
dataset_options = sc._jvm.com.adobe.platform.dataset.DataSetOptions
pd0 = spark.read.format("com.adobe.platform.dataset")
  .option(dataset_options.orgId(), "310C6D375BA5248F0A494212@AdobeOrg")
  .load("5e68141134492718af974844")

Uso de PySpark 3 (Spark 2.4) - Núcleo Python 3
%dataset read --datasetId 5e68141134492718af974844 --dataFrame pd0

Elemento
Descripción
pd0
Nombre del objeto dataframe pandas que se va a usar o crear.
Magia personalizada para acceso a datos en el núcleo Python3.
Las siguientes imágenes resaltan las diferencias clave en la carga de datos para PySpark 2.3 y PySpark 2.4. Este ejemplo utiliza los blocs de notas de inicio de Agregación proporcionados en JupyterLab Launcher.
Carga de datos en PySpark 2.3 (conjunto de datos de luminancia): obsoleto
Carga de datos en PySpark 2.4 (conjunto de datos de luminancia)
Con PySpark 3 (Spark 2.4) sc = spark.sparkContext se define en la carga.
Carga de datos de la plataforma de Experience Cloud en PySpark 2.3, obsoleto
Carga de datos de la plataforma de Experience Cloud en PySpark 2.4
Con PySpark 3 (Spark 2.4) org_id y ya no dataset_id es necesario definir. Además, df = spark.read.format se ha sustituido por una magia personalizada %dataset para facilitar la lectura y escritura de conjuntos de datos.
Elemento
description
Magia personalizada para acceso a datos en el núcleo Python3.
—mode se puede establecer en interactive o batch . El valor predeterminado para —mode es interactive . Se recomienda utilizar el batch modo cuando se leen grandes cantidades de datos.

Creación de un datafame local

Con PySpark 3 (Spark 2.4) ya no se admite %% sparkMagic. Ya no se pueden utilizar las siguientes operaciones:
  • %%help
  • %%info
  • %%cleanup
  • %%delete
  • %%configure
  • %%local
En la tabla siguiente se describen los cambios necesarios para convertir consultas %%sql chismosas:
Portátil PySpark 3 (Spark 2.3, obsoleto) PySpark 3 (Spark 2.4)
Kernel PySpark 3 Python 3
Código
%%sql -o dfselect * de sparkdf


 %%sql -o df -n limitselect * de sparkdf


%%sql -o df -qselect * de sparkdf


 %%sql -o df -r fractionselect * de sparkdf


df = spark.sql(''' SELECT * FROM sparkdf'')


df = spark.sql(''' SELECT * FROM sparkdf LIMIT limit''')


df = spark.sql(''' SELECT * FROM sparkdf LIMIT limit''')


sample_df = df.sample(fraction)


También puede especificar una muestra de raíz opcional, como un booleano conSustitución, fracción de doble o una semilla larga.
Las siguientes imágenes resaltan las diferencias clave para crear un datafame local en PySpark 2.3 y PySpark 2.4. Este ejemplo utiliza los blocs de notas de inicio de Agregación proporcionados en JupyterLab Launcher.
Crear un dataframe local PySpark 2.3, obsoleto
Crear un datafame local PySpark 2.4
Con PySpark 3 (Spark 2.4) %%sql SparkMagic ya no se admite y se ha sustituido por lo siguiente:

Escribir en un conjunto de datos

Con la introducción de Spark 2.4, se proporciona la magia personalizada que hace que la escritura de conjuntos de datos sea más limpia. %dataset Para escribir en un conjunto de datos, utilice el siguiente ejemplo de Spark 2.4:
Uso de PySpark 3 (Spark 2.3 - desaprobado) - Núcleo de PySpark 3
userToken = spark.sparkContext.getConf().get("spark.yarn.appMasterEnv.USER_TOKEN")
serviceToken = spark.sparkContext.getConf().get("spark.yarn.appMasterEnv.SERVICE_TOKEN")
serviceApiKey = spark.sparkContext.getConf().get("spark.yarn.appMasterEnv.SERVICE_API_KEY")

dataset_options = sc._jvm.com.adobe.platform.dataset.DataSetOptions

pd0.write.format("com.adobe.platform.dataset")
  .option(dataset_options.orgId(), "310C6D375BA5248F0A494212@AdobeOrg")
  .option(dataset_options.userToken(), userToken)
  .option(dataset_options.serviceToken(), serviceToken)
  .option(dataset_options.serviceApiKey(), serviceApiKey)
  .save("5e68141134492718af974844")

Uso de PySpark 3 (Spark 2.4) - Núcleo Python 3
%dataset write --datasetId 5e68141134492718af974844 --dataFrame pd0
pd0.describe()
pd0.show(10, False)

Elemento
description
pd0
Nombre del objeto dataframe pandas que se va a usar o crear.
Magia personalizada para acceso a datos en el núcleo Python3.
—mode se puede establecer en interactive o batch . El valor predeterminado para —mode es interactive . Se recomienda utilizar el batch modo cuando se leen grandes cantidades de datos.
Las siguientes imágenes resaltan las diferencias clave para volver a escribir datos en Platform en PySpark 2.3 y PySpark 2.4. Este ejemplo utiliza los blocs de notas de inicio de Agregación proporcionados en JupyterLab Launcher.
Escritura de datos en Platform PySpark 2.3, obsoleto
Escritura de datos en Platform PySpark 2.4
Con PySpark 3 (Spark 2.4), la %dataset magia personalizada elimina la necesidad de definir valores como userToken , serviceToken , serviceApiKey y .option . Además, ya no orgId es necesario definir.

Guía de migración de portátiles Spark 2.3 a Spark 2.4 (Scala)

Con la introducción de Spark 2.4 a los portátiles JupyterLab, los portátiles Spark (Spark 2.3) ya existentes utilizan el núcleo Scala en lugar del núcleo Spark. Esto significa que el código existente que se ejecuta en Spark (Spark 2.3) no es compatible con Scala (Spark 2.4). Además, todos los nuevos portátiles Spark deben utilizar Scala (Spark 2.4) en el iniciador JupyterLab.
La chispa (Spark 2.3) está obsoleta y está configurada para eliminarse en una versión posterior. Todos los ejemplos existentes están configurados para reemplazarse con ejemplos de Scala (Spark 2.4).
Para convertir los blocs de notas Spark (Spark 2.3) existentes a Scala (Spark 2.4), siga los ejemplos que se describen a continuación:

Kernel

Los portátiles Scala (Spark 2.4) utilizan el núcleo Scala en lugar del núcleo Spark desaprobado que se utiliza en los portátiles Spark (Spark 2.3 - desaprobado).
Para confirmar o cambiar el núcleo en la interfaz de usuario de JupyterLab, seleccione el botón del núcleo ubicado en la barra de navegación superior derecha del bloc de notas. Aparece la ventana emergente Seleccionar núcleo . Si está utilizando uno de los blocs de notas predefinidos del iniciador, el núcleo está preseleccionado. El ejemplo siguiente utiliza el bloc de notas Scala Clustering en JupyterLab Launcher.
Al seleccionar el menú desplegable, se abre una lista de núcleos disponibles.
Para los blocs de notas Scala (Spark 2.4), seleccione el núcleo Scala y confirme haciendo clic en el botón Seleccionar .

Inicializando SparkSession

Todos los blocs de notas Scala (Spark 2.4) requieren que inicialice la sesión con el siguiente código repetitivo:
Portátil Chispa (Spark 2.3 - obsoleto) Scala (Spark 2.4)
Kernel Spark Scala
code no se requiere código
import org.apache.spark.sql.{ SparkSession } val spark = SparkSession.builder() .master("local") .getOrCreate()


La imagen de Scala (Spark 2.4) a continuación resalta la diferencia clave en la inicialización de sparkSession con el núcleo Spark 2.3 Spark y el núcleo Spark 2.4 Scala. En este ejemplo se utilizan los blocs de notas de inicio de clústeres proporcionados en JupyterLab Launcher.
Chispa (Spark 2.3 - obsoleto)
Spark (Spark 2.3 - desaprobado) utiliza el núcleo Spark, y por lo tanto, no era necesario que definiera Spark.
Scala (Spark 2.4)
El uso de Spark 2.4 con el núcleo Scala requiere que usted defina val spark e importe SparkSesson para leer o escribir:

Datos de Consulta

Con Scala (Spark 2.4) ya no se admite %% sparkMagic. Ya no se pueden utilizar las siguientes operaciones:
  • %%help
  • %%info
  • %%cleanup
  • %%delete
  • %%configure
  • %%local
En la tabla siguiente se describen los cambios necesarios para convertir consultas %%sql chismosas:
Portátil Chispa (Spark 2.3 - obsoleto) Scala (Spark 2.4)
Kernel Spark Scala
code
%%sql -o dfselect * de sparkdf


%%sql -o df -n limitselect * de sparkdf


%%sql -o df -qselect * de sparkdf


%%sql -o df -r fractionselect * de sparkdf


val df = spark.sql(''' SELECT * FROM sparkdf'')


val df = spark.sql(''' SELECT * FROM sparkdf LIMIT limit''')


val df = spark.sql(''' SELECT * FROM sparkdf LIMIT limit''')


val sample_df = df.sample(fraction) 

La imagen de Scala (Spark 2.4) a continuación resalta las principales diferencias en la realización de consultas con el núcleo Spark 2.3 y Spark 2.4 Scala. En este ejemplo se utilizan los blocs de notas de inicio de clústeres proporcionados en JupyterLab Launcher.
Chispa (Spark 2.3 - obsoleto)
El bloc de notas Spark (Spark 2.3 - desaprobado) utiliza el núcleo Spark. El núcleo Spark soporta y utiliza %%sql sparkMagic.
Scala (Spark 2.4)
El núcleo Scala ya no soporta %%sql sparkMagic. Es necesario convertir el código sparkMagic existente.

Leer un conjunto de datos

En Spark 2.3 era necesario definir variables para option los valores utilizados para leer datos o utilizar los valores sin procesar en la celda de código. En Scala, puede utilizar sys.env("PYDASDK_IMS_USER_TOKEN") para declarar y devolver un valor, lo que elimina la necesidad de definir variables como, por ejemplo, var userToken . En el siguiente ejemplo de Scala (Spark 2.4), sys.env se utiliza para definir y devolver todos los valores necesarios para leer un conjunto de datos.
Uso de Spark (Spark 2.3 - desaprobado) - Núcleo de chispa
import com.adobe.platform.dataset.DataSetOptions
var df1 = spark.read.format("com.adobe.platform.dataset")
  .option(DataSetOptions.orgId, "310C6D375BA5248F0A494212@AdobeOrg")
  .option(DataSetOptions.batchId, "dbe154d3-197a-4e6c-80f8-9b7025eea2b9")
  .load("5e68141134492718af974844")

Uso de Scala (Spark 2.4) - Núcleo Scala
import org.apache.spark.sql.{Dataset, SparkSession}
val spark = SparkSession.builder().master("local").getOrCreate()
val df1 = spark.read.format("com.adobe.platform.query")
  .option("user-token", sys.env("PYDASDK_IMS_USER_TOKEN"))
  .option("ims-org", sys.env("IMS_ORG_ID"))
  .option("api-key", sys.env("PYDASDK_IMS_CLIENT_ID"))
  .option("service-token", sys.env("PYDASDK_IMS_SERVICE_TOKEN"))
  .option("mode", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .load()

Elemento
description
df1
Variable que representa el dataframe de Pandas utilizado para leer y escribir datos.
user-token
El token de usuario que se obtiene automáticamente mediante sys.env("PYDASDK_IMS_USER_TOKEN") .
service-token
El token de servicio que se obtiene automáticamente mediante sys.env("PYDASDK_IMS_SERVICE_TOKEN") .
ims-org
Su id de ims-org que se obtiene automáticamente mediante sys.env("IMS_ORG_ID") .
api-key
La clave de API que se obtiene automáticamente mediante sys.env("PYDASDK_IMS_CLIENT_ID") .
Las siguientes imágenes resaltan las diferencias clave en la carga de datos con las Spark 2.3 y Spark 2.4. En este ejemplo se utilizan los blocs de notas de inicio de clústeres proporcionados en JupyterLab Launcher.
Chispa (Spark 2.3 - obsoleto)
El bloc de notas Spark (Spark 2.3 - desaprobado) utiliza el núcleo Spark. Las dos celdas siguientes muestran un ejemplo de carga del conjunto de datos con una ID de conjunto de datos especificada en el intervalo de fechas de (2019-3-21, 2019-3-29).
Scala (Spark 2.4)
El bloc de notas Scala (Spark 2.4) utiliza el núcleo Scala que requiere más valores al configurarlo, como se destaca en la primera celda de código. Además, var mdata requiere que se rellenen más option valores. En este bloc de notas, el código mencionado anteriormente para inicializar SparkSession se incluye en la celda de var mdata código.
En Scala, puede utilizar sys.env() para declarar y devolver un valor desde dentro option . Esto elimina la necesidad de definir variables si sabe que sólo se van a usar una sola vez. El ejemplo siguiente toma val userToken el ejemplo anterior y lo declara en línea dentro de option :
.option("user-token", sys.env("PYDASDK_IMS_USER_TOKEN"))

Escribir en un conjunto de datos

De manera similar a leer un conjunto de datos , escribir en un conjunto de datos requiere valores adicionales option descritos en el ejemplo siguiente. En Scala, puede utilizar sys.env("PYDASDK_IMS_USER_TOKEN") para declarar y devolver un valor, lo que elimina la necesidad de definir variables como, por ejemplo, var userToken . En el siguiente ejemplo de Scala, sys.env se utiliza para definir y devolver todos los valores necesarios para escribir en un conjunto de datos.
Uso de Spark (Spark 2.3 - desaprobado) - Núcleo de chispa
import com.adobe.platform.dataset.DataSetOptions

var userToken = spark.sparkContext.getConf.getOption("spark.yarn.appMasterEnv.USER_TOKEN").get
var serviceToken = spark.sparkContext.getConf.getOption("spark.yarn.appMasterEnv.SERVICE_TOKEN").get
var serviceApiKey = spark.sparkContext.getConf.getOption("spark.yarn.appMasterEnv.SERVICE_API_KEY").get

df1.write.format("com.adobe.platform.dataset")
  .option(DataSetOptions.orgId, "310C6D375BA5248F0A494212@AdobeOrg")
  .option(DataSetOptions.userToken, userToken)
  .option(DataSetOptions.serviceToken, serviceToken)
  .option(DataSetOptions.serviceApiKey, serviceApiKey)
  .save("5e68141134492718af974844")

Uso de Scala (Spark 2.4) - Núcleo Scala
import org.apache.spark.sql.{Dataset, SparkSession}

val spark = SparkSession.builder().master("local").getOrCreate()

df1.write.format("com.adobe.platform.query")
  .option("user-token", sys.env("PYDASDK_IMS_USER_TOKEN"))
  .option("service-token", sys.env("PYDASDK_IMS_SERVICE_TOKEN"))
  .option("ims-org", sys.env("IMS_ORG_ID"))
  .option("api-key", sys.env("PYDASDK_IMS_CLIENT_ID"))
  .option("mode", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .save()

Elemento
description
df1
Variable que representa el dataframe de Pandas utilizado para leer y escribir datos.
user-token
El token de usuario que se obtiene automáticamente mediante sys.env("PYDASDK_IMS_USER_TOKEN") .
service-token
El token de servicio que se obtiene automáticamente mediante sys.env("PYDASDK_IMS_SERVICE_TOKEN") .
ims-org
Su id de ims-org que se obtiene automáticamente mediante sys.env("IMS_ORG_ID") .
api-key
La clave de API que se obtiene automáticamente mediante sys.env("PYDASDK_IMS_CLIENT_ID") .