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

package/lib/jobs/pyspark-flex-etl-job.d.ts

@@ -0,0 +1,83 @@
+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';
+/**
+ * Properties for PySparkFlexEtlJob
+ */
+export interface PySparkFlexEtlJobProps 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;
+    /**
+     * Additional Python files that AWS Glue adds to the Python path before executing your script.
+     *
+     * @default - no extra python files specified.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraPythonFiles?: Code[];
+    /**
+     * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
+     *
+     * @default - no extra files specified.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraFiles?: 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 declare class PySparkFlexEtlJob 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;
+    /**
+     * PySparkFlexEtlJob constructor
+     */
+    constructor(scope: Construct, id: string, props: PySparkFlexEtlJobProps);
+    /**
+     *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;
+}

package/lib/jobs/pyspark-flex-etl-job.js

@@ -0,0 +1,134 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PySparkFlexEtlJob = 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");
+/**
+ * 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
+ */
+class PySparkFlexEtlJob extends job_1.Job {
+    /**
+     * PySparkFlexEtlJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_PySparkFlexEtlJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, PySparkFlexEtlJob);
+            }
+            throw error;
+        }
+        // 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);
+        // Conbine command line arguments into a single line item
+        const defaultArguments = {
+            ...execuatbleArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...sparkUIArgs?.args,
+            ...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.ETL,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+                pythonVersion: constants_1.PythonVersion.THREE,
+            },
+            glueVersion: props.glueVersion ? props.glueVersion : constants_1.GlueVersion.V3_0,
+            workerType: props.workerType ? props.workerType : constants_1.WorkerType.G_1X,
+            numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,
+            maxRetries: props.maxRetries,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            notificationProperty: props.notifyDelayAfter ? { notifyDelayAfter: props.notifyDelayAfter.toMinutes() } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            executionClass: constants_1.ExecutionClass.FLEX,
+            jobRunQueuingEnabled: false,
+            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 (props.extraPythonFiles && props.extraPythonFiles.length > 0) {
+            args['--extra-py-files'] = props.extraPythonFiles.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        if (props.extraFiles && props.extraFiles.length > 0) {
+            args['--extra-files'] = props.extraFiles.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        return args;
+    }
+    /**
+     * Set the arguments for sparkUI with best practices enabled by default
+     *
+     * @returns An array of arguments for enabling sparkUI
+     */
+    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.PySparkFlexEtlJob = PySparkFlexEtlJob;
+_a = JSII_RTTI_SYMBOL_1;
+PySparkFlexEtlJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.PySparkFlexEtlJob", version: "2.177.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pyspark-flex-etl-job.js","sourceRoot":"","sources":["pyspark-flex-etl-job.ts"],"names":[],"mappings":"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","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, PythonVersion, WorkerType, ExecutionClass } from '../constants';\nimport { SparkUIProps, SparkUILoggingLocation, validateSparkUiPrefix, cleanSparkUiPrefixForGrant } from './spark-ui-utils';\nimport * as cdk from 'aws-cdk-lib/core';\nimport { Code } from '../code';\n\n/**\n * Properties for PySparkFlexEtlJob\n */\nexport interface PySparkFlexEtlJobProps 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   * Specifies configuration properties of a notification (optional).\n   * After a job run starts, the number of minutes to wait before sending a job run delay notification.\n   * @default - undefined\n   */\n  readonly notifyDelayAfter?: cdk.Duration;\n\n  /**\n   * Additional Python files that AWS Glue adds to the Python path before executing your script.\n   *\n   * @default - no extra python files specified.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraPythonFiles?: Code[];\n\n  /**\n   * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.\n   *\n   * @default - no extra files specified.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraFiles?: Code[];\n\n}\n\n/**\n * Flex Jobs class\n *\n * Flex jobs supports Python and Scala language.\n * The flexible execution class is appropriate for non-urgent jobs such as\n * pre-production jobs, testing, and one-time data loads.\n * Flexible job runs are supported for jobs using AWS Glue version 3.0 or later and G.1X or\n * G.2X worker types but will default to the latest version of Glue (currently Glue 3.0.)\n *\n * Similar to ETL, we’ll enable these features: —enable-metrics, —enable-spark-ui,\n * —enable-continuous-cloudwatch-log\n */\nexport class PySparkFlexEtlJob 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   * PySparkFlexEtlJob constructor\n   */\n  constructor(scope: Construct, id: string, props: PySparkFlexEtlJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\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    // 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    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        pythonVersion: PythonVersion.THREE,\n      },\n      glueVersion: props.glueVersion ? props.glueVersion : GlueVersion.V3_0,\n      workerType: props.workerType ? props.workerType : WorkerType.G_1X,\n      numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,\n      maxRetries: props.maxRetries,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      notificationProperty: props.notifyDelayAfter ? { notifyDelayAfter: props.notifyDelayAfter.toMinutes() } : 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      executionClass: ExecutionClass.FLEX,\n      jobRunQueuingEnabled: false,\n      defaultArguments,\n\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: PySparkFlexEtlJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.PYTHON;\n\n    if (props.extraPythonFiles && props.extraPythonFiles.length > 0) {\n      args['--extra-py-files'] = props.extraPythonFiles.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n    if (props.extraFiles && props.extraFiles.length > 0) {\n      args['--extra-files'] = props.extraFiles.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n\n    return args;\n  }\n\n  /**\n   * Set the arguments for sparkUI with best practices enabled by default\n   *\n   * @returns An array of arguments for enabling sparkUI\n   */\n\n  private setupSparkUI(role: iam.IRole, sparkUiProps: SparkUIProps) {\n\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/pyspark-streaming-job.d.ts

@@ -0,0 +1,82 @@
+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 Python Spark ETL job
+ */
+export interface PySparkStreamingJobProps 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;
+    /**
+     * Extra Python Files S3 URL (optional)
+     * S3 URL where additional python dependencies are located
+     *
+     * @default - no extra files
+     */
+    readonly extraPythonFiles?: Code[];
+    /**
+     * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
+     *
+     * @default - no extra files specified.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraFiles?: 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;
+}
+/**
+ * Python Spark Streaming Jobs class
+ *
+ * A Streaming job is similar to an ETL job, except that it performs ETL on data streams
+ * using the Apache Spark Structured Streaming framework.
+ * These jobs will default to use Python 3.9.
+ *
+ * Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL,
+ * it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker
+ * and 4.0 version for streaming jobs which developers can override.
+ * We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ */
+export declare class PySparkStreamingJob 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;
+    /**
+     * PySparkStreamingJob constructor
+     */
+    constructor(scope: Construct, id: string, props: PySparkStreamingJobProps);
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @param props
+     * @returns An array of arguments for Glue to use on execution
+     */
+    private executableArguments;
+    private setupSparkUI;
+}

package/lib/jobs/pyspark-streaming-job.js

@@ -0,0 +1,128 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PySparkStreamingJob = 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 aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const spark_ui_utils_1 = require("./spark-ui-utils");
+/**
+ * Python Spark Streaming Jobs class
+ *
+ * A Streaming job is similar to an ETL job, except that it performs ETL on data streams
+ * using the Apache Spark Structured Streaming framework.
+ * These jobs will default to use Python 3.9.
+ *
+ * Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL,
+ * it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker
+ * and 4.0 version for streaming jobs which developers can override.
+ * We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ */
+class PySparkStreamingJob extends job_1.Job {
+    /**
+     * PySparkStreamingJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_PySparkStreamingJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, PySparkStreamingJob);
+            }
+            throw error;
+        }
+        // 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 executableArgs = this.executableArguments(props);
+        // Conbine command line arguments into a single line item
+        const defaultArguments = {
+            ...executableArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...sparkUIArgs?.args,
+            ...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.STREAMING,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+                pythonVersion: constants_1.PythonVersion.THREE,
+            },
+            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
+     *
+     * @param props
+     * @returns An array of arguments for Glue to use on execution
+     */
+    executableArguments(props) {
+        const args = {};
+        args['--job-language'] = constants_1.JobLanguage.PYTHON;
+        if (props.extraPythonFiles && props.extraPythonFiles.length > 0) {
+            args['--extra-py-files'] = props.extraPythonFiles.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        if (props.extraFiles && props.extraFiles.length > 0) {
+            args['--extra-files'] = props.extraFiles.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.PySparkStreamingJob = PySparkStreamingJob;
+_a = JSII_RTTI_SYMBOL_1;
+PySparkStreamingJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.PySparkStreamingJob", version: "2.177.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pyspark-streaming-job.js","sourceRoot":"","sources":["pyspark-streaming-job.ts"],"names":[],"mappings":";;;;;;AAAA,mDAA8C;AAC9C,2CAA2C;AAC3C,+CAA8D;AAC9D,+BAA2C;AAE3C,4CAA4F;AAC5F,qDAA2H;AA+C3H;;;;;;;;;;;GAWG;AACH,MAAa,mBAAoB,SAAQ,SAAG;IAc1C;;OAEG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA+B;QACvE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,YAAY,EAAE,KAAK,CAAC,OAAO;SAC5B,CAAC,CAAC;;;;;;+CApBM,mBAAmB;;;;QAsB5B,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,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,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,SAAS;gBACvB,cAAc,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC;gBAClD,aAAa,EAAE,yBAAa,CAAC,KAAK;aACnC;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;;;;;OAKG;IACK,mBAAmB,CAAC,KAA+B;QACzD,MAAM,IAAI,GAA8B,EAAE,CAAC;QAC3C,IAAI,CAAC,gBAAgB,CAAC,GAAG,uBAAW,CAAC,MAAM,CAAC;QAE5C,IAAI,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChE,IAAI,CAAC,kBAAkB,CAAC,GAAG,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtG,CAAC;QACD,IAAI,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpD,IAAI,CAAC,eAAe,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7F,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;;AAlHH,kDAmHC","sourcesContent":["import { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Bucket, BucketEncryption } from 'aws-cdk-lib/aws-s3';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, JobLanguage, PythonVersion, WorkerType } from '../constants';\nimport { SparkUIProps, SparkUILoggingLocation, validateSparkUiPrefix, cleanSparkUiPrefixForGrant } from './spark-ui-utils';\nimport { Code } from '../code';\n\n/**\n * Properties for creating a Python Spark ETL job\n */\nexport interface PySparkStreamingJobProps 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   * Extra Python Files S3 URL (optional)\n   * S3 URL where additional python dependencies are located\n   *\n   * @default - no extra files\n   */\n  readonly extraPythonFiles?: Code[];\n\n  /**\n   * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.\n   *\n   * @default - no extra files specified.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraFiles?: 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 * Python Spark Streaming Jobs class\n *\n * A Streaming job is similar to an ETL job, except that it performs ETL on data streams\n * using the Apache Spark Structured Streaming framework.\n * These jobs will default to use Python 3.9.\n *\n * Similar to ETL jobs, streaming job supports Scala and Python languages. Similar to ETL,\n * it supports G1 and G2 worker type and 2.0, 3.0 and 4.0 version. We’ll default to G2 worker\n * and 4.0 version for streaming jobs which developers can override.\n * We will enable —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.\n */\nexport class PySparkStreamingJob 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   * PySparkStreamingJob constructor\n   */\n  constructor(scope: Construct, id: string, props: PySparkStreamingJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\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 executableArgs = this.executableArguments(props);\n\n    // Conbine command line arguments into a single line item\n    const defaultArguments = {\n      ...executableArgs,\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n      ...sparkUIArgs?.args,\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.STREAMING,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n        pythonVersion: PythonVersion.THREE,\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   * @param props\n   * @returns An array of arguments for Glue to use on execution\n   */\n  private executableArguments(props: PySparkStreamingJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.PYTHON;\n\n    if (props.extraPythonFiles && props.extraPythonFiles.length > 0) {\n      args['--extra-py-files'] = props.extraPythonFiles.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n    if (props.extraFiles && props.extraFiles.length > 0) {\n      args['--extra-files'] = props.extraFiles.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/python-shell-job.d.ts

@@ -0,0 +1,55 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Job, JobProperties } from './job';
+import { Construct } from 'constructs';
+import { PythonVersion, MaxCapacity } from '../constants';
+/**
+ * Properties for creating a Python Shell job
+ */
+export interface PythonShellJobProps extends JobProperties {
+    /**
+    * Python Version
+    * The version of Python to use to execute this job
+    * @default 3.9 for Shell Jobs
+    **/
+    readonly pythonVersion?: PythonVersion;
+    /**
+     * The total number of DPU to assign to the Python Job
+     *
+     * @default 0.0625
+     */
+    readonly maxCapacity?: MaxCapacity;
+    /**
+     * 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 false
+     */
+    readonly jobRunQueuingEnabled?: boolean;
+}
+/**
+ * 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.
+ */
+export declare class PythonShellJob extends Job {
+    readonly jobArn: string;
+    readonly jobName: string;
+    readonly role: iam.IRole;
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+    * PythonShellJob constructor
+    */
+    constructor(scope: Construct, id: string, props: PythonShellJobProps);
+    /**
+    * Set the executable arguments with best practices enabled by default
+    *
+    * @returns An array of arguments for Glue to use on execution
+    */
+    private executableArguments;
+}