@aws-cdk/aws-glue-alpha 2.176.0-alpha.0 → 2.178.0-alpha.0

package/lib/jobs/python-shell-job.js

@@ -0,0 +1,99 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonShellJob = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_glue_1 = require("aws-cdk-lib/aws-glue");
+const iam = require("aws-cdk-lib/aws-iam");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * Python Shell Jobs class
+ *
+ * A Python shell job runs Python scripts as a shell and supports a Python version that
+ * depends on the AWS Glue version you are using.
+ * This can be used to schedule and run tasks that don't require an Apache Spark environment.
+ */
+class PythonShellJob extends job_1.Job {
+    /**
+     * PythonShellJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, { physicalName: props.jobName });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_PythonShellJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, PythonShellJob);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        // Set up role and permissions for principal
+        this.role = props.role, {
+            assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],
+        };
+        this.grantPrincipal = this.role;
+        // Enable CloudWatch metrics and continuous logging by default as a best practice
+        const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);
+        const profilingMetricsArgs = { '--enable-metrics': '' };
+        const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };
+        // Gather executable arguments
+        const executableArgs = this.executableArguments(props);
+        // Combine command line arguments into a single line item
+        const defaultArguments = {
+            ...executableArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...this.checkNoReservedArgs(props.defaultArguments),
+        };
+        const jobResource = new aws_glue_1.CfnJob(this, 'Resource', {
+            name: props.jobName,
+            description: props.description,
+            role: this.role.roleArn,
+            command: {
+                name: constants_1.JobType.PYTHON_SHELL,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+                pythonVersion: props.pythonVersion ? props.pythonVersion : constants_1.PythonVersion.THREE_NINE,
+            },
+            glueVersion: props.glueVersion ? props.glueVersion : constants_1.GlueVersion.V3_0,
+            maxCapacity: props.maxCapacity ? props.maxCapacity : constants_1.MaxCapacity.DPU_1_16TH,
+            maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries ? props.maxRetries : 0,
+            jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            defaultArguments,
+        });
+        const resourceName = this.getResourceNameAttribute(jobResource.ref);
+        this.jobArn = this.buildJobArn(this, resourceName);
+        this.jobName = resourceName;
+    }
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    executableArguments(props) {
+        const args = {};
+        args['--job-language'] = constants_1.JobLanguage.PYTHON;
+        // If no Python version set (default 3.9) or the version is set to 3.9 then set library-set argument
+        if (!props.pythonVersion || props.pythonVersion == constants_1.PythonVersion.THREE_NINE) {
+            // Selecting this option includes common libraries for Python 3.9
+            args['library-set'] = 'analytics';
+        }
+        return args;
+    }
+}
+exports.PythonShellJob = PythonShellJob;
+_a = JSII_RTTI_SYMBOL_1;
+PythonShellJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.PythonShellJob", version: "2.178.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"python-shell-job.js","sourceRoot":"","sources":["python-shell-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, PythonVersion, MaxCapacity, JobLanguage } from '../constants';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Properties for creating a Python Shell job\n */\nexport interface PythonShellJobProps extends JobProperties {\n  /**\n   * Python Version\n   * The version of Python to use to execute this job\n   * @default 3.9 for Shell Jobs\n   **/\n  readonly pythonVersion?: PythonVersion;\n\n  /**\n   * The total number of DPU to assign to the Python Job\n   *\n   * @default 0.0625\n   */\n  readonly maxCapacity?: MaxCapacity;\n\n  /**\n   * Specifies whether job run queuing is enabled for the job runs for this job.\n   * A value of true means job run queuing is enabled for the job runs.\n   * If false or not populated, the job runs will not be considered for queueing.\n   * If this field does not match the value set in the job run, then the value from\n   * the job run field will be used. This property must be set to false for flex jobs.\n   * If this property is enabled, maxRetries must be set to zero.\n   *\n   * @default false\n   */\n  readonly jobRunQueuingEnabled?: boolean;\n}\n\n/**\n * Python Shell Jobs class\n *\n * A Python shell job runs Python scripts as a shell and supports a Python version that\n * depends on the AWS Glue version you are using.\n * This can be used to schedule and run tasks that don't require an Apache Spark environment.\n */\nexport class PythonShellJob extends Job {\n  public readonly jobArn: string;\n  public readonly jobName: string;\n  public readonly role: iam.IRole;\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * PythonShellJob constructor\n   */\n  constructor(scope: Construct, id: string, props: PythonShellJobProps) {\n    super(scope, id, { physicalName: props.jobName });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Set up role and permissions for principal\n    this.role = props.role, {\n      assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],\n    };\n    this.grantPrincipal = this.role;\n\n    // Enable CloudWatch metrics and continuous logging by default as a best practice\n    const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);\n    const profilingMetricsArgs = { '--enable-metrics': '' };\n    const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };\n\n    // Gather executable arguments\n    const executableArgs = this.executableArguments(props);\n\n    // Combine command line arguments into a single line item\n    const defaultArguments = {\n      ...executableArgs,\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n      ...this.checkNoReservedArgs(props.defaultArguments),\n    };\n\n    const jobResource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.PYTHON_SHELL,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n        pythonVersion: props.pythonVersion ? props.pythonVersion : PythonVersion.THREE_NINE,\n      },\n      glueVersion: props.glueVersion ? props.glueVersion : GlueVersion.V3_0,\n      maxCapacity: props.maxCapacity ? props.maxCapacity : MaxCapacity.DPU_1_16TH,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries ? props.maxRetries : 0,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      defaultArguments,\n    });\n\n    const resourceName = this.getResourceNameAttribute(jobResource.ref);\n    this.jobArn = this.buildJobArn(this, resourceName);\n    this.jobName = resourceName;\n  }\n\n  /**\n   * Set the executable arguments with best practices enabled by default\n   *\n   * @returns An array of arguments for Glue to use on execution\n   */\n  private executableArguments(props: PythonShellJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.PYTHON;\n\n    // If no Python version set (default 3.9) or the version is set to 3.9 then set library-set argument\n    if (!props.pythonVersion || props.pythonVersion == PythonVersion.THREE_NINE) {\n      // Selecting this option includes common libraries for Python 3.9\n      args['library-set'] = 'analytics';\n    }\n\n    return args;\n  }\n}\n"]}

package/lib/jobs/ray-job.d.ts

@@ -0,0 +1,44 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Job, JobProperties } from './job';
+import { Construct } from 'constructs';
+import { Runtime } from '../constants';
+/**
+ * Properties for creating a Ray Glue job
+ */
+export interface RayJobProps extends JobProperties {
+    /**
+     * Sets the Ray runtime environment version
+     *
+     * @default - Runtime version will default to Ray2.4
+     */
+    readonly runtime?: Runtime;
+    /**
+     * Specifies whether job run queuing is enabled for the job runs for this job.
+     * A value of true means job run queuing is enabled for the job runs.
+     * If false or not populated, the job runs will not be considered for queueing.
+     * If this field does not match the value set in the job run, then the value from
+     * the job run field will be used. This property must be set to false for flex jobs.
+     * If this property is enabled, maxRetries must be set to zero.
+     *
+     * @default - no job run queuing
+     */
+    readonly jobRunQueuingEnabled?: boolean;
+}
+/**
+ * Ray Jobs class
+ *
+ * Glue Ray jobs use worker type Z.2X and Glue version 4.0.
+ * These are not overrideable since these are the only configuration that
+ * Glue Ray jobs currently support. The runtime defaults to Ray2.4 and min
+ * workers defaults to 3.
+ */
+export declare class RayJob extends Job {
+    readonly jobArn: string;
+    readonly jobName: string;
+    readonly role: iam.IRole;
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * RayJob constructor
+     */
+    constructor(scope: Construct, id: string, props: RayJobProps);
+}

package/lib/jobs/ray-job.js

@@ -0,0 +1,89 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RayJob = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_glue_1 = require("aws-cdk-lib/aws-glue");
+const iam = require("aws-cdk-lib/aws-iam");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * Ray Jobs class
+ *
+ * Glue Ray jobs use worker type Z.2X and Glue version 4.0.
+ * These are not overrideable since these are the only configuration that
+ * Glue Ray jobs currently support. The runtime defaults to Ray2.4 and min
+ * workers defaults to 3.
+ */
+class RayJob extends job_1.Job {
+    /**
+     * RayJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_RayJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, RayJob);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        this.jobName = props.jobName ?? '';
+        // Set up role and permissions for principal
+        this.role = props.role, {
+            assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],
+        };
+        this.grantPrincipal = this.role;
+        // Enable CloudWatch metrics and continuous logging by default as a best practice
+        const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);
+        const profilingMetricsArgs = { '--enable-metrics': '' };
+        const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };
+        // Combine command line arguments into a single line item
+        const defaultArguments = {
+            ...this.checkNoReservedArgs(props.defaultArguments),
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+        };
+        if (props.workerType && props.workerType !== constants_1.WorkerType.Z_2X) {
+            throw new Error('Ray jobs only support Z.2X worker type');
+        }
+        const jobResource = new aws_glue_1.CfnJob(this, 'Resource', {
+            name: props.jobName,
+            description: props.description,
+            role: this.role.roleArn,
+            command: {
+                name: constants_1.JobType.RAY,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+                runtime: props.runtime ? props.runtime : constants_1.Runtime.RAY_TWO_FOUR,
+            },
+            glueVersion: constants_1.GlueVersion.V4_0,
+            workerType: props.workerType ? props.workerType : constants_1.WorkerType.Z_2X,
+            numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 3,
+            maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,
+            jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            defaultArguments,
+        });
+        const resourceName = this.getResourceNameAttribute(jobResource.ref);
+        this.jobArn = this.buildJobArn(this, resourceName);
+        this.jobName = resourceName;
+    }
+}
+exports.RayJob = RayJob;
+_a = JSII_RTTI_SYMBOL_1;
+RayJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.RayJob", version: "2.178.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ray-job.js","sourceRoot":"","sources":["ray-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, WorkerType, Runtime } from '../constants';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Properties for creating a Ray Glue job\n */\nexport interface RayJobProps extends JobProperties {\n  /**\n   * Sets the Ray runtime environment version\n   *\n   * @default - Runtime version will default to Ray2.4\n   */\n  readonly runtime?: Runtime;\n\n  /**\n   * Specifies whether job run queuing is enabled for the job runs for this job.\n   * A value of true means job run queuing is enabled for the job runs.\n   * If false or not populated, the job runs will not be considered for queueing.\n   * If this field does not match the value set in the job run, then the value from\n   * the job run field will be used. This property must be set to false for flex jobs.\n   * If this property is enabled, maxRetries must be set to zero.\n   *\n   * @default - no job run queuing\n   */\n  readonly jobRunQueuingEnabled?: boolean;\n}\n\n/**\n * Ray Jobs class\n *\n * Glue Ray jobs use worker type Z.2X and Glue version 4.0.\n * These are not overrideable since these are the only configuration that\n * Glue Ray jobs currently support. The runtime defaults to Ray2.4 and min\n * workers defaults to 3.\n */\nexport class RayJob extends Job {\n  public readonly jobArn: string;\n  public readonly jobName: string;\n  public readonly role: iam.IRole;\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * RayJob constructor\n   */\n  constructor(scope: Construct, id: string, props: RayJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    this.jobName = props.jobName ?? '';\n\n    // Set up role and permissions for principal\n    this.role = props.role, {\n      assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],\n    };\n    this.grantPrincipal = this.role;\n\n    // Enable CloudWatch metrics and continuous logging by default as a best practice\n    const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);\n    const profilingMetricsArgs = { '--enable-metrics': '' };\n    const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };\n\n    // Combine command line arguments into a single line item\n    const defaultArguments = {\n      ...this.checkNoReservedArgs(props.defaultArguments),\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n    };\n\n    if (props.workerType && props.workerType !== WorkerType.Z_2X) {\n      throw new Error('Ray jobs only support Z.2X worker type');\n    }\n\n    const jobResource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.RAY,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n        runtime: props.runtime ? props.runtime : Runtime.RAY_TWO_FOUR,\n      },\n      glueVersion: GlueVersion.V4_0,\n      workerType: props.workerType ? props.workerType : WorkerType.Z_2X,\n      numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers: 3,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      defaultArguments,\n    });\n\n    const resourceName = this.getResourceNameAttribute(jobResource.ref);\n    this.jobArn = this.buildJobArn(this, resourceName);\n    this.jobName = resourceName;\n  }\n}\n"]}

package/lib/jobs/scala-spark-etl-job.d.ts

@@ -0,0 +1,78 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Job, JobProperties } from './job';
+import { Construct } from 'constructs';
+import { SparkUIProps, SparkUILoggingLocation } from './spark-ui-utils';
+import { Code } from '../code';
+/**
+ * Properties for creating a Scala Spark ETL job
+ */
+export interface ScalaSparkEtlJobProps extends JobProperties {
+    /**
+     * Enables the Spark UI debugging and monitoring with the specified props.
+     *
+     * @default - Spark UI debugging and monitoring is disabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUI?: SparkUIProps;
+    /**
+     * Class name (required for Scala scripts)
+     * Package and class name for the entry point of Glue job execution for
+     * Java scripts
+     **/
+    readonly className: string;
+    /**
+     * Extra Jars S3 URL (optional)
+     * S3 URL where additional jar dependencies are located
+     * @default - no extra jar files
+     */
+    readonly extraJars?: Code[];
+    /**
+     * Specifies whether job run queuing is enabled for the job runs for this job.
+     * A value of true means job run queuing is enabled for the job runs.
+     * If false or not populated, the job runs will not be considered for queueing.
+     * If this field does not match the value set in the job run, then the value from
+     * the job run field will be used. This property must be set to false for flex jobs.
+     * If this property is enabled, maxRetries must be set to zero.
+     *
+     * @default - no job run queuing
+     */
+    readonly jobRunQueuingEnabled?: boolean;
+}
+/**
+ * Spark ETL Jobs class
+ *
+ * ETL jobs support pySpark and Scala languages, for which there are separate
+ * but similar constructors. ETL jobs default to the G2 worker type, but you
+ * can override this default with other supported worker type values
+ * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can
+ * override to 3.0. The following ETL features are enabled by default:
+ * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ * You can find more details about version, worker type and other features
+ * in Glue's public documentation.
+ */
+export declare class ScalaSparkEtlJob extends Job {
+    readonly jobArn: string;
+    readonly jobName: string;
+    readonly role: iam.IRole;
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * The Spark UI logs location if Spark UI monitoring and debugging is enabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUILoggingLocation?: SparkUILoggingLocation;
+    /**
+     * ScalaSparkEtlJob constructor
+     */
+    constructor(scope: Construct, id: string, props: ScalaSparkEtlJobProps);
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    private executableArguments;
+    private setupSparkUI;
+}

package/lib/jobs/scala-spark-etl-job.js

@@ -0,0 +1,134 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalaSparkEtlJob = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_glue_1 = require("aws-cdk-lib/aws-glue");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const spark_ui_utils_1 = require("./spark-ui-utils");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * Spark ETL Jobs class
+ *
+ * ETL jobs support pySpark and Scala languages, for which there are separate
+ * but similar constructors. ETL jobs default to the G2 worker type, but you
+ * can override this default with other supported worker type values
+ * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can
+ * override to 3.0. The following ETL features are enabled by default:
+ * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ * You can find more details about version, worker type and other features
+ * in Glue's public documentation.
+ */
+class ScalaSparkEtlJob extends job_1.Job {
+    /**
+     * ScalaSparkEtlJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ScalaSparkEtlJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, ScalaSparkEtlJob);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        // Set up role and permissions for principal
+        this.role = props.role, {
+            assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],
+        };
+        this.grantPrincipal = this.role;
+        // Enable SparkUI by default as a best practice
+        const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;
+        this.sparkUILoggingLocation = sparkUIArgs?.location;
+        // Enable CloudWatch metrics and continuous logging by default as a best practice
+        const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);
+        const profilingMetricsArgs = { '--enable-metrics': '' };
+        const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };
+        // Gather executable arguments
+        const execuatbleArgs = this.executableArguments(props);
+        // Mandatory className argument
+        if (props.className === undefined) {
+            throw new Error('className must be set for Scala ETL Jobs');
+        }
+        // Conbine command line arguments into a single line item
+        const defaultArguments = {
+            ...execuatbleArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...sparkUIArgs?.args,
+            ...this.checkNoReservedArgs(props.defaultArguments),
+        };
+        if ((!props.workerType && props.numberOfWorkers !== undefined) || (props.workerType && props.numberOfWorkers === undefined)) {
+            throw new Error('Both workerType and numberOfWorkers must be set');
+        }
+        const jobResource = new aws_glue_1.CfnJob(this, 'Resource', {
+            name: props.jobName,
+            description: props.description,
+            role: this.role.roleArn,
+            command: {
+                name: constants_1.JobType.ETL,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+            },
+            glueVersion: props.glueVersion ? props.glueVersion : constants_1.GlueVersion.V4_0,
+            workerType: props.workerType ? props.workerType : constants_1.WorkerType.G_1X,
+            numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,
+            maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,
+            jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            defaultArguments,
+        });
+        const resourceName = this.getResourceNameAttribute(jobResource.ref);
+        this.jobArn = this.buildJobArn(this, resourceName);
+        this.jobName = resourceName;
+    }
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    executableArguments(props) {
+        const args = {};
+        args['--job-language'] = constants_1.JobLanguage.SCALA;
+        args['--class'] = props.className;
+        if (props.extraJars && props.extraJars?.length > 0) {
+            args['--extra-jars'] = props.extraJars.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        return args;
+    }
+    setupSparkUI(role, sparkUiProps) {
+        (0, spark_ui_utils_1.validateSparkUiPrefix)(sparkUiProps.prefix);
+        const bucket = sparkUiProps.bucket ?? new aws_s3_1.Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: aws_s3_1.BucketEncryption.S3_MANAGED });
+        bucket.grantReadWrite(role, (0, spark_ui_utils_1.cleanSparkUiPrefixForGrant)(sparkUiProps.prefix));
+        const args = {
+            '--enable-spark-ui': 'true',
+            '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\/?$/, '/'), // path will always end with a slash
+        };
+        return {
+            location: {
+                prefix: sparkUiProps.prefix,
+                bucket,
+            },
+            args,
+        };
+    }
+}
+exports.ScalaSparkEtlJob = ScalaSparkEtlJob;
+_a = JSII_RTTI_SYMBOL_1;
+ScalaSparkEtlJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.ScalaSparkEtlJob", version: "2.178.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scala-spark-etl-job.js","sourceRoot":"","sources":["scala-spark-etl-job.ts"],"names":[],"mappings":";;;;;;AAAA,2CAA2C;AAC3C,+CAA8D;AAC9D,mDAA8C;AAC9C,+BAA2C;AAE3C,4CAA6E;AAC7E,qDAA2H;AAE3H,8EAA8E;AA2C9E;;;;;;;;;;;GAWG;AACH,MAAa,gBAAiB,SAAQ,SAAG;IAcvC;;OAEG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA4B;QACpE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,YAAY,EAAE,KAAK,CAAC,OAAO;SAC5B,CAAC,CAAC;;;;;;+CApBM,gBAAgB;;;;QAqBzB,mCAAmC;QACnC,IAAA,wCAAoB,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAElC,4CAA4C;QAC5C,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE;YACtB,SAAS,EAAE,IAAI,GAAG,CAAC,gBAAgB,CAAC,oBAAoB,CAAC;YACzD,eAAe,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,wBAAwB,CAAC,iCAAiC,CAAC,CAAC;SACjG,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC;QAEhC,+CAA+C;QAC/C,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACpG,IAAI,CAAC,sBAAsB,GAAG,WAAW,EAAE,QAAQ,CAAC;QAEpD,iFAAiF;QACjF,MAAM,qBAAqB,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAC9F,MAAM,oBAAoB,GAAG,EAAE,kBAAkB,EAAE,EAAE,EAAE,CAAC;QACxD,MAAM,wBAAwB,GAAG,EAAE,gCAAgC,EAAE,MAAM,EAAE,CAAC;QAE9E,8BAA8B;QAC9B,MAAM,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAEvD,+BAA+B;QAC/B,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;QAED,yDAAyD;QACzD,MAAM,gBAAgB,GAAG;YACvB,GAAG,cAAc;YACjB,GAAG,qBAAqB;YACxB,GAAG,oBAAoB;YACvB,GAAG,wBAAwB;YAC3B,GAAG,WAAW,EAAE,IAAI;YACpB,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,gBAAgB,CAAC;SACpD,CAAC;QAEF,IAAI,CAAC,CAAC,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,eAAe,KAAK,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,eAAe,KAAK,SAAS,CAAC,EAAE,CAAC;YAC5H,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,iBAAM,CAAC,IAAI,EAAE,UAAU,EAAE;YAC/C,IAAI,EAAE,KAAK,CAAC,OAAO;YACnB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO;YACvB,OAAO,EAAE;gBACP,IAAI,EAAE,mBAAO,CAAC,GAAG;gBACjB,cAAc,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC;aACnD;YACD,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,uBAAW,CAAC,IAAI;YACrE,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,sBAAU,CAAC,IAAI;YACjE,eAAe,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE;YACnE,UAAU,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU;YAC7D,oBAAoB,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK;YACrF,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,SAAS;YACvG,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE;YACnC,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;YAC9H,qBAAqB,EAAE,KAAK,CAAC,qBAAqB,EAAE,yBAAyB;YAC7E,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,gBAAgB;SACjB,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC;KAC7B;IAED;;;;OAIG;IACK,mBAAmB,CAAC,KAA4B;QACtD,MAAM,IAAI,GAA8B,EAAE,CAAC;QAC3C,IAAI,CAAC,gBAAgB,CAAC,GAAG,uBAAW,CAAC,KAAK,CAAC;QAC3C,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,SAAU,CAAC;QAEnC,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,EAAE,CAAC;YACnD,IAAI,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3F,CAAC;QAED,OAAO,IAAI,CAAC;KACb;IAEO,YAAY,CAAC,IAAe,EAAE,YAA0B;QAC9D,IAAA,sCAAqB,EAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,IAAI,IAAI,eAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,yBAAgB,CAAC,UAAU,EAAE,CAAC,CAAC;QACvI,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,IAAA,2CAA0B,EAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;QAC7E,MAAM,IAAI,GAAG;YACX,mBAAmB,EAAE,MAAM;YAC3B,yBAAyB,EAAE,MAAM,CAAC,cAAc,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,oCAAoC;SACjI,CAAC;QAEF,OAAO;YACL,QAAQ,EAAE;gBACR,MAAM,EAAE,YAAY,CAAC,MAAM;gBAC3B,MAAM;aACP;YACD,IAAI;SACL,CAAC;KACH;;AAzHH,4CA0HC","sourcesContent":["import * as iam from 'aws-cdk-lib/aws-iam';\nimport { Bucket, BucketEncryption } from 'aws-cdk-lib/aws-s3';\nimport { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, JobLanguage, WorkerType } from '../constants';\nimport { SparkUIProps, SparkUILoggingLocation, validateSparkUiPrefix, cleanSparkUiPrefixForGrant } from './spark-ui-utils';\nimport { Code } from '../code';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Properties for creating a Scala Spark ETL job\n */\nexport interface ScalaSparkEtlJobProps extends JobProperties {\n  /**\n   * Enables the Spark UI debugging and monitoring with the specified props.\n   *\n   * @default - Spark UI debugging and monitoring is disabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly sparkUI?: SparkUIProps;\n\n  /**\n   * Class name (required for Scala scripts)\n   * Package and class name for the entry point of Glue job execution for\n   * Java scripts\n   **/\n  readonly className: string;\n\n  /**\n   * Extra Jars S3 URL (optional)\n   * S3 URL where additional jar dependencies are located\n   * @default - no extra jar files\n   */\n  readonly extraJars?: Code[];\n\n  /**\n   * Specifies whether job run queuing is enabled for the job runs for this job.\n   * A value of true means job run queuing is enabled for the job runs.\n   * If false or not populated, the job runs will not be considered for queueing.\n   * If this field does not match the value set in the job run, then the value from\n   * the job run field will be used. This property must be set to false for flex jobs.\n   * If this property is enabled, maxRetries must be set to zero.\n   *\n   * @default - no job run queuing\n   */\n  readonly jobRunQueuingEnabled?: boolean;\n}\n\n/**\n * Spark ETL Jobs class\n *\n * ETL jobs support pySpark and Scala languages, for which there are separate\n * but similar constructors. ETL jobs default to the G2 worker type, but you\n * can override this default with other supported worker type values\n * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can\n * override to 3.0. The following ETL features are enabled by default:\n * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.\n * You can find more details about version, worker type and other features\n * in Glue's public documentation.\n */\nexport class ScalaSparkEtlJob extends Job {\n  public readonly jobArn: string;\n  public readonly jobName: string;\n  public readonly role: iam.IRole;\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The Spark UI logs location if Spark UI monitoring and debugging is enabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  public readonly sparkUILoggingLocation?: SparkUILoggingLocation;\n\n  /**\n   * ScalaSparkEtlJob constructor\n   */\n  constructor(scope: Construct, id: string, props: ScalaSparkEtlJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Set up role and permissions for principal\n    this.role = props.role, {\n      assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],\n    };\n    this.grantPrincipal = this.role;\n\n    // Enable SparkUI by default as a best practice\n    const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;\n    this.sparkUILoggingLocation = sparkUIArgs?.location;\n\n    // Enable CloudWatch metrics and continuous logging by default as a best practice\n    const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);\n    const profilingMetricsArgs = { '--enable-metrics': '' };\n    const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };\n\n    // Gather executable arguments\n    const execuatbleArgs = this.executableArguments(props);\n\n    // Mandatory className argument\n    if (props.className === undefined) {\n      throw new Error('className must be set for Scala ETL Jobs');\n    }\n\n    // Conbine command line arguments into a single line item\n    const defaultArguments = {\n      ...execuatbleArgs,\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n      ...sparkUIArgs?.args,\n      ...this.checkNoReservedArgs(props.defaultArguments),\n    };\n\n    if ((!props.workerType && props.numberOfWorkers !== undefined) || (props.workerType && props.numberOfWorkers === undefined)) {\n      throw new Error('Both workerType and numberOfWorkers must be set');\n    }\n\n    const jobResource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.ETL,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n      },\n      glueVersion: props.glueVersion ? props.glueVersion : GlueVersion.V4_0,\n      workerType: props.workerType ? props.workerType : WorkerType.G_1X,\n      numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      defaultArguments,\n    });\n\n    const resourceName = this.getResourceNameAttribute(jobResource.ref);\n    this.jobArn = this.buildJobArn(this, resourceName);\n    this.jobName = resourceName;\n  }\n\n  /**\n   * Set the executable arguments with best practices enabled by default\n   *\n   * @returns An array of arguments for Glue to use on execution\n   */\n  private executableArguments(props: ScalaSparkEtlJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.SCALA;\n    args['--class'] = props.className!;\n\n    if (props.extraJars && props.extraJars?.length > 0) {\n      args['--extra-jars'] = props.extraJars.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n\n    return args;\n  }\n\n  private setupSparkUI(role: iam.IRole, sparkUiProps: SparkUIProps) {\n    validateSparkUiPrefix(sparkUiProps.prefix);\n    const bucket = sparkUiProps.bucket ?? new Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: BucketEncryption.S3_MANAGED });\n    bucket.grantReadWrite(role, cleanSparkUiPrefixForGrant(sparkUiProps.prefix));\n    const args = {\n      '--enable-spark-ui': 'true',\n      '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\\/?$/, '/'), // path will always end with a slash\n    };\n\n    return {\n      location: {\n        prefix: sparkUiProps.prefix,\n        bucket,\n      },\n      args,\n    };\n  }\n}\n"]}

package/lib/jobs/scala-spark-flex-etl-job.d.ts

@@ -0,0 +1,109 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Job, JobProperties } from './job';
+import { Construct } from 'constructs';
+import { SparkUIProps, SparkUILoggingLocation } from './spark-ui-utils';
+import * as cdk from 'aws-cdk-lib/core';
+import { Code } from '../code';
+/**
+ * Flex Jobs class
+ *
+ * Flex jobs supports Python and Scala language.
+ * The flexible execution class is appropriate for non-urgent jobs such as
+ * pre-production jobs, testing, and one-time data loads.
+ * Flexible job runs are supported for jobs using AWS Glue version 3.0 or later and G.1X or
+ * G.2X worker types but will default to the latest version of Glue (currently Glue 3.0.)
+ *
+ * Similar to ETL, we’ll enable these features: —enable-metrics, —enable-spark-ui,
+ * —enable-continuous-cloudwatch-log
+ *
+ */
+export interface ScalaSparkFlexEtlJobProps extends JobProperties {
+    /**
+     * Enables the Spark UI debugging and monitoring with the specified props.
+     *
+     * @default - Spark UI debugging and monitoring is disabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUI?: SparkUIProps;
+    /**
+     * Specifies configuration properties of a notification (optional).
+     * After a job run starts, the number of minutes to wait before sending a job run delay notification.
+     * @default - undefined
+     */
+    readonly notifyDelayAfter?: cdk.Duration;
+    /**
+     * The fully qualified Scala class name that serves as the entry point for the job.
+     *
+     * @see `--class` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly className: string;
+    /**
+     * Additional Java .jar files that AWS Glue adds to the Java classpath before executing your script.
+     * Only individual files are supported, directories are not supported.
+     *
+     * @default [] - no extra jars are added to the classpath
+     *
+     * @see `--extra-jars` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraJars?: Code[];
+    /**
+     * Setting this value to true prioritizes the customer's extra JAR files in the classpath.
+     *
+     * @default false - priority is not given to user-provided jars
+     *
+     * @see `--user-jars-first` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraJarsFirst?: boolean;
+    /**
+     * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
+     * Only individual files are supported, directories are not supported.
+     *
+     * @default [] - no extra files are copied to the working directory
+     *
+     * @see `--extra-files` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraFiles?: Code[];
+}
+/**
+ * Spark ETL Jobs class
+ *
+ * ETL jobs support pySpark and Scala languages, for which there are separate
+ * but similar constructors. ETL jobs default to the G2 worker type, but you
+ * can override this default with other supported worker type values
+ * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can
+ * override to 3.0. The following ETL features are enabled by default:
+ * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ * You can find more details about version, worker type and other features
+ * in Glue's public documentation.
+ */
+export declare class ScalaSparkFlexEtlJob extends Job {
+    readonly jobArn: string;
+    readonly jobName: string;
+    readonly role: iam.IRole;
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * The Spark UI logs location if Spark UI monitoring and debugging is enabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUILoggingLocation?: SparkUILoggingLocation;
+    /**
+     * ScalaSparkFlexEtlJob constructor
+     */
+    constructor(scope: Construct, id: string, props: ScalaSparkFlexEtlJobProps);
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    private executableArguments;
+    /**
+     * Set the arguments for sparkUI with best practices enabled by default
+     *
+     * @returns An array of arguments for enabling sparkUI
+     */
+    private setupSparkUI;
+}