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

package/README.md

@@ -17,116 +17,332 @@
 
 This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
 
-## Job
+## README
+
+[AWS Glue](https://aws.amazon.com/glue/) is a serverless data integration
+service that makes it easier to discover, prepare, move, and integrate data
+from multiple sources for analytics, machine learning (ML), and application
+development.
+
+The Glue L2 construct has convenience methods working backwards from common
+use cases and sets required parameters to defaults that align with recommended
+best practices for each job type. It also provides customers with a balance
+between flexibility via optional parameter overrides, and opinionated
+interfaces that discouraging anti-patterns, resulting in reduced time to develop
+and deploy new resources.
+
+### References
+
+* [Glue Launch Announcement](https://aws.amazon.com/blogs/aws/launch-aws-glue-now-generally-available/)
+* [Glue Documentation](https://docs.aws.amazon.com/glue/index.html)
+* [Glue L1 (CloudFormation) Constructs](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Glue.html)
+* Prior version of the [@aws-cdk/aws-glue-alpha module](https://github.com/aws/aws-cdk/blob/v2.51.1/packages/%40aws-cdk/aws-glue/README.md)
+
+## Create a Glue Job
+
+A Job encapsulates a script that connects to data sources, processes
+them, and then writes output to a data target. There are four types of Glue
+Jobs: Spark (ETL and Streaming), Python Shell, Ray, and Flex Jobs. Most
+of the required parameters for these jobs are common across all types,
+but there are a few differences depending on the languages supported
+and features provided by each type. For all job types, the L2 defaults
+to AWS best practice recommendations, such as:
+
+* Use of Secrets Manager for Connection JDBC strings
+* Glue job autoscaling
+* Default parameter values for Glue job creation
+
+This iteration of the L2 construct introduces breaking changes to
+the existing glue-alpha-module, but these changes streamline the developer
+experience, introduce new constants for defaults, and replacing synth-time
+validations with interface contracts for enforcement of the parameter combinations
+that Glue supports. As an opinionated construct, the Glue L2 construct does
+not allow developers to create resources that use non-current versions
+of Glue or deprecated language dependencies (e.g. deprecated versions of Python).
+As always, L1s allow you to specify a wider range of parameters if you need
+or want to use alternative configurations.
+
+Optional and required parameters for each job are enforced via interface
+rather than validation; see [Glue's public documentation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api.html)
+for more granular details.
 
-A `Job` encapsulates a script that connects to data sources, processes them, and then writes output to a data target.
+### Spark Jobs
 
-There are 3 types of jobs supported by AWS Glue: Spark ETL, Spark Streaming, and Python Shell jobs.
+1. **ETL Jobs**
 
-The `glue.JobExecutable` allows you to specify the type of job, the language to use and the code assets required by the job.
+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](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html).
 
-`glue.Code` allows you to refer to the different code assets required by the job, either from an existing S3 location or from a local file path.
+Reference the pyspark-etl-jobs.test.ts and scalaspark-etl-jobs.test.ts unit tests
+for examples of required-only and optional job parameters when creating these
+types of jobs.
 
-`glue.ExecutionClass` allows you to specify `FLEX` or `STANDARD`. `FLEX` is appropriate for non-urgent jobs such as pre-production jobs, testing, and one-time data loads.
+For the sake of brevity, examples are shown using the pySpark job variety.
 
-### Spark Jobs
+Example with only required parameters:
+
+```ts
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkEtlJob(stack, 'PySparkETLJob', {
+  role,
+  script,
+  jobName: 'PySparkETLJob',
+});
+```
 
-These jobs run in an Apache Spark environment managed by AWS Glue.
+Example with optional override parameters:
+
+```ts
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkEtlJob(stack, 'PySparkETLJob', {
+  jobName: 'PySparkETLJobCustomName',
+  description: 'This is a description',
+  role,
+  script,
+  glueVersion: glue.GlueVersion.V3_0,
+  continuousLogging: { enabled: false },
+  workerType: glue.WorkerType.G_2X,
+  maxConcurrentRuns: 100,
+  timeout: cdk.Duration.hours(2),
+  connections: [glue.Connection.fromConnectionName(stack, 'Connection', 'connectionName')],
+  securityConfiguration: glue.SecurityConfiguration.fromSecurityConfigurationName(stack, 'SecurityConfig', 'securityConfigName'),
+  tags: {
+    FirstTagName: 'FirstTagValue',
+    SecondTagName: 'SecondTagValue',
+    XTagName: 'XTagValue',
+  },
+  numberOfWorkers: 2,
+  maxRetries: 2,
+});
+```
 
-#### ETL Jobs
+**Streaming Jobs**
 
-An ETL job processes data in batches using Apache Spark.
+Streaming jobs are similar to ETL jobs, except that they perform ETL on data
+streams using the Apache Spark Structured Streaming framework. Some Spark
+job features are not available to Streaming ETL jobs. They support Scala
+and pySpark languages. PySpark streaming jobs default Python 3.9,
+which you can override with any non-deprecated version of Python. It
+defaults to the G2 worker type and Glue 4.0, both of which you can override.
+The following best practice features are enabled by default:
+`—enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log`.
+
+Reference the pyspark-streaming-jobs.test.ts and scalaspark-streaming-jobs.test.ts 
+unit tests for examples of required-only and optional job parameters when creating
+these types of jobs.
+
+Example with only required parameters:
+
+```ts
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkStreamingJob(stack, 'ImportedJob', { role, script });
+```
+
+Example with optional override parameters:
 
 ```ts
-declare const bucket: s3.Bucket;
-new glue.Job(this, 'ScalaSparkEtlJob', {
-  executable: glue.JobExecutable.scalaEtl({
-    glueVersion: glue.GlueVersion.V5_0,
-    script: glue.Code.fromBucket(bucket, 'src/com/example/HelloWorld.scala'),
-    className: 'com.example.HelloWorld',
-    extraJars: [glue.Code.fromBucket(bucket, 'jars/HelloWorld.jar')],
-  }),
-  workerType: glue.WorkerType.G_8X,
-  description: 'an example Scala ETL job',
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkStreamingJob(stack, 'PySparkStreamingJob', {
+  jobName: 'PySparkStreamingJobCustomName',
+  description: 'This is a description',
+  role,
+  script,
+  glueVersion: glue.GlueVersion.V3_0,
+  continuousLogging: { enabled: false },
+  workerType: glue.WorkerType.G_2X,
+  maxConcurrentRuns: 100,
+  timeout: cdk.Duration.hours(2),
+  connections: [glue.Connection.fromConnectionName(stack, 'Connection', 'connectionName')],
+  securityConfiguration: glue.SecurityConfiguration.fromSecurityConfigurationName(stack, 'SecurityConfig', 'securityConfigName'),
+  tags: {
+    FirstTagName: 'FirstTagValue',
+    SecondTagName: 'SecondTagValue',
+    XTagName: 'XTagValue',
+  },
+  numberOfWorkers: 2,
+  maxRetries: 2,
 });
 ```
 
-#### Streaming Jobs
+**Flex Jobs**
+
+The flexible execution class is appropriate for non-urgent jobs such as
+pre-production jobs, testing, and one-time data loads. Flexible jobs default
+to Glue version 3.0 and worker type `G_2X`. The following best practice
+features are enabled by default:
+`—enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log`
 
-A Streaming job is similar to an ETL job, except that it performs ETL on data streams. It uses the Apache Spark Structured Streaming framework. Some Spark job features are not available to streaming ETL jobs.
+Reference the pyspark-flex-etl-jobs.test.ts and scalaspark-flex-etl-jobs.test.ts 
+unit tests for examples of required-only and optional job parameters when creating
+these types of jobs.
+
+Example with only required parameters:
 
 ```ts
-new glue.Job(this, 'PythonSparkStreamingJob', {
-  executable: glue.JobExecutable.pythonStreaming({
-    glueVersion: glue.GlueVersion.V5_0,
-    pythonVersion: glue.PythonVersion.THREE,
-    script: glue.Code.fromAsset(path.join(__dirname, 'job-script', 'hello_world.py')),
-  }),
-  description: 'an example Python Streaming job',
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkFlexEtlJob(stack, 'ImportedJob', { role, script });
+```
+
+Example with optional override parameters:
+
+```ts
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkEtlJob(stack, 'pySparkEtlJob', {
+  jobName: 'pySparkEtlJob',
+  description: 'This is a description',
+  role,
+  script,
+  glueVersion: glue.GlueVersion.V3_0,
+  continuousLogging: { enabled: false },
+  workerType: glue.WorkerType.G_2X,
+  maxConcurrentRuns: 100,
+  timeout: cdk.Duration.hours(2),
+  connections: [glue.Connection.fromConnectionName(stack, 'Connection', 'connectionName')],
+  securityConfiguration: glue.SecurityConfiguration.fromSecurityConfigurationName(stack, 'SecurityConfig', 'securityConfigName'),
+  tags: {
+    FirstTagName: 'FirstTagValue',
+    SecondTagName: 'SecondTagValue',
+    XTagName: 'XTagValue',
+  },
+  numberOfWorkers: 2,
+  maxRetries: 2,
 });
 ```
 
 ### Python Shell Jobs
 
-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. Currently, three flavors are supported:
+Python shell jobs support a Python version that depends on the AWS Glue
+version you use. These can be used to schedule and run tasks that don't
+require an Apache Spark environment. Python shell jobs default to
+Python 3.9 and a MaxCapacity of `0.0625`. Python 3.9 supports pre-loaded
+analytics libraries using the `library-set=analytics` flag, which is
+enabled by default.
+
+Reference the pyspark-shell-job.test.ts unit tests for examples of 
+required-only and optional job parameters when creating these types of jobs.
 
-* PythonVersion.TWO (2.7; EOL)
-* PythonVersion.THREE (3.6)
-* PythonVersion.THREE_NINE (3.9)
+Example with only required parameters:
 
 ```ts
-declare const bucket: s3.Bucket;
-new glue.Job(this, 'PythonShellJob', {
-  executable: glue.JobExecutable.pythonShell({
-    glueVersion: glue.GlueVersion.V1_0,
-    pythonVersion: glue.PythonVersion.THREE,
-    script: glue.Code.fromBucket(bucket, 'script.py'),
-  }),
-  description: 'an example Python Shell job',
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PythonShellJob(stack, 'ImportedJob', { role, script });
+```
+
+Example with optional override parameters:
+
+```ts
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PythonShellJob(stack, 'PythonShellJob', {
+  jobName: 'PythonShellJobCustomName',
+  description: 'This is a description',
+  pythonVersion: glue.PythonVersion.TWO,
+  maxCapacity: glue.MaxCapacity.DPU_1,
+  role,
+  script,
+  glueVersion: glue.GlueVersion.V2_0,
+  continuousLogging: { enabled: false },
+  workerType: glue.WorkerType.G_2X,
+  maxConcurrentRuns: 100,
+  timeout: cdk.Duration.hours(2),
+  connections: [glue.Connection.fromConnectionName(stack, 'Connection', 'connectionName')],
+  securityConfiguration: glue.SecurityConfiguration.fromSecurityConfigurationName(stack, 'SecurityConfig', 'securityConfigName'),
+  tags: {
+    FirstTagName: 'FirstTagValue',
+    SecondTagName: 'SecondTagValue',
+    XTagName: 'XTagValue',
+  },
+  numberOfWorkers: 2,
+  maxRetries: 2,
 });
 ```
 
 ### Ray Jobs
 
-These jobs run in a Ray environment managed by AWS Glue.
+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.
+
+Reference the ray-job.test.ts unit tests for examples of required-only and
+optional job parameters when creating these types of jobs.
+
+Example with only required parameters:
 
 ```ts
-new glue.Job(this, 'RayJob', {
-  executable: glue.JobExecutable.pythonRay({
-    glueVersion: glue.GlueVersion.V5_0,
-    pythonVersion: glue.PythonVersion.THREE_NINE,
-    runtime: glue.Runtime.RAY_TWO_FOUR,
-    script: glue.Code.fromAsset(path.join(__dirname, 'job-script', 'hello_world.py')),
-  }),
-  workerType: glue.WorkerType.Z_2X,
-  workerCount: 2,
-  description: 'an example Ray job'
-});
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.RayJob(stack, 'ImportedJob', { role, script });
 ```
 
-### Enable Spark UI
-
-Enable Spark UI setting the `sparkUI` property.
+Example with optional override parameters:
 
 ```ts
-new glue.Job(this, 'EnableSparkUI', {
-  jobName: 'EtlJobWithSparkUIPrefix',
-  sparkUI: {
-    enabled: true,
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.RayJob(stack, 'ImportedJob', {
+  role,
+  script,
+  jobName: 'RayCustomJobName',
+  description: 'This is a description',
+  workerType: glue.WorkerType.Z_2X,
+  numberOfWorkers: 5,
+  runtime: glue.Runtime.RAY_TWO_FOUR,
+  maxRetries: 3,
+  maxConcurrentRuns: 100,
+  timeout: cdk.Duration.hours(2),
+  connections: [glue.Connection.fromConnectionName(stack, 'Connection', 'connectionName')],
+  securityConfiguration: glue.SecurityConfiguration.fromSecurityConfigurationName(stack, 'SecurityConfig', 'securityConfigName'),
+  tags: {
+    FirstTagName: 'FirstTagValue',
+    SecondTagName: 'SecondTagValue',
+    XTagName: 'XTagValue',
   },
-  executable: glue.JobExecutable.pythonEtl({
-    glueVersion: glue.GlueVersion.V3_0,
-    pythonVersion: glue.PythonVersion.THREE,
-    script: glue.Code.fromAsset(path.join(__dirname, 'job-script', 'hello_world.py')),
-  }),
 });
 ```
 
-The `sparkUI` property also allows the specification of an s3 bucket and a bucket prefix.
-
-See [documentation](https://docs.aws.amazon.com/glue/latest/dg/add-job.html) for more information on adding jobs in Glue.
-
 ### Enable Job Run Queuing
 
 AWS Glue job queuing monitors your account level quotas and limits. If quotas or limits are insufficient to start a Glue job run, AWS Glue will automatically queue the job and wait for limits to free up. Once limits become available, AWS Glue will retry the job run. Glue jobs will queue for limits like max concurrent job runs per account, max concurrent Data Processing Units (DPU), and resource unavailable due to IP address exhaustion in Amazon Virtual Private Cloud (Amazon VPC).
@@ -134,20 +350,93 @@ AWS Glue job queuing monitors your account level quotas and limits. If quotas or
 Enable job run queuing by setting the `jobRunQueuingEnabled` property to `true`.
 
 ```ts
-new glue.Job(this, 'EnableRunQueuing', {
-  jobName: 'EtlJobWithRunQueuing',
-  executable: glue.JobExecutable.pythonEtl({
-    glueVersion: glue.GlueVersion.V5_0,
-    pythonVersion: glue.PythonVersion.THREE,
-    script: glue.Code.fromAsset(path.join(__dirname, 'job-script', 'hello_world.py')),
-  }),
-  jobRunQueuingEnabled: true,
+import * as cdk from 'aws-cdk-lib';
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const stack: cdk.Stack;
+declare const role: iam.IRole;
+declare const script: glue.Code;
+new glue.PySparkEtlJob(stack, 'PySparkETLJob', {
+  role,
+  script,
+  jobName: 'PySparkETLJob',
+  jobRunQueuingEnabled: true
 });
 ```
 
-## Connection
+### Uploading scripts from the CDK app repository to S3
+
+Similar to other L2 constructs, the Glue L2 automates uploading / updating
+scripts to S3 via an optional fromAsset parameter pointing to a script
+in the local file structure. You provide the existing S3 bucket and
+path to which you'd like the script to be uploaded.
 
-A `Connection` allows Glue jobs, crawlers and development endpoints to access certain types of data stores. For example, to create a network connection to connect to a data source within a VPC:
+Reference the unit tests for examples of repo and S3 code target examples.
+
+### Workflow Triggers
+
+You can use Glue workflows to create and visualize complex
+extract, transform, and load (ETL) activities involving multiple crawlers,
+jobs, and triggers. Standalone triggers are an anti-pattern, so you must
+create triggers from within a workflow using the L2 construct.
+
+Within a workflow object, there are functions to create different
+types of triggers with actions and predicates. You then add those triggers
+to jobs.
+
+StartOnCreation defaults to true for all trigger types, but you can
+override it if you prefer for your trigger not to start on creation.
+
+Reference the workflow-triggers.test.ts unit tests for examples of creating
+workflows and triggers.
+
+1. **On-Demand Triggers**
+
+On-demand triggers can start glue jobs or crawlers. This construct provides
+convenience functions to create on-demand crawler or job triggers. The constructor
+takes an optional description parameter, but abstracts the requirement of an
+actions list using the job or crawler objects using conditional types.
+
+1. **Scheduled Triggers**
+
+You can create scheduled triggers using cron expressions. This construct
+provides daily, weekly, and monthly convenience functions,
+as well as a custom function that allows you to create your own
+custom timing using the [existing event Schedule class](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Schedule.html)
+without having to build your own cron expressions. The L2 extracts
+the expression that Glue requires from the Schedule object. The constructor
+takes an optional description and a list of jobs or crawlers as actions.
+
+#### **3. Notify  Event Triggers**
+
+There are two types of notify event triggers: batching and non-batching.
+For batching triggers, you must specify `BatchSize`. For non-batching
+triggers, `BatchSize` defaults to 1. For both triggers, `BatchWindow`
+defaults to 900 seconds, but you can override the window to align with
+your workload's requirements.
+
+#### **4. Conditional Triggers**
+
+Conditional triggers have a predicate and actions associated with them.
+The trigger actions are executed when the predicateCondition is true.
+
+### Connection Properties
+
+A `Connection` allows Glue jobs, crawlers and development endpoints to access
+certain types of data stores.
+
+***Secrets Management
+    **You must specify JDBC connection credentials in Secrets Manager and
+    provide the Secrets Manager Key name as a property to the job connection.
+
+* **Networking - the CDK determines the best fit subnet for Glue connection
+configuration
+    **The prior version of the glue-alpha-module requires the developer to
+    specify the subnet of the Connection when it’s defined. Now, you can still
+    specify the specific subnet you want to use, but are no longer required
+    to. You are only required to provide a VPC and either a public or private
+    subnet selection. Without a specific subnet provided, the L2 leverages the
+    existing [EC2 Subnet Selection](https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_ec2/SubnetSelection.html)
+    library to make the best choice selection for the subnet.
 
 ```ts
 declare const securityGroup: ec2.SecurityGroup;
@@ -377,20 +666,20 @@ If you have a table with a large number of partitions that grows over time, cons
 ```ts
 declare const myDatabase: glue.Database;
 new glue.S3Table(this, 'MyTable', {
-    database: myDatabase,
-    columns: [{
-        name: 'col1',
-        type: glue.Schema.STRING,
-    }],
-    partitionKeys: [{
-        name: 'year',
-        type: glue.Schema.SMALL_INT,
-    }, {
-        name: 'month',
-        type: glue.Schema.SMALL_INT,
-    }],
-    dataFormat: glue.DataFormat.JSON,
-    enablePartitionFiltering: true,
+  database: myDatabase,
+  columns: [{
+      name: 'col1',
+      type: glue.Schema.STRING,
+  }],
+  partitionKeys: [{
+      name: 'year',
+      type: glue.Schema.SMALL_INT,
+  }, {
+      name: 'month',
+      type: glue.Schema.SMALL_INT,
+  }],
+  dataFormat: glue.DataFormat.JSON,
+  enablePartitionFiltering: true,
 });
 ```
 
@@ -488,7 +777,7 @@ new glue.S3Table(this, 'MyTable', {
 declare const myDatabase: glue.Database;
 // KMS key is created automatically
 new glue.S3Table(this, 'MyTable', {
-  encryption: glue.TableEncryption.CLIENT_SIDE_KMS,
+  encryption: glue.TableEncryption.CLIENT_SIDE_KMS, 
   // ...
   database: myDatabase,
   columns: [{
@@ -546,69 +835,43 @@ new glue.S3Table(this, 'MyTable', {
   // ...
   database: myDatabase,
   dataFormat: glue.DataFormat.JSON,
-});
-```
-
-### Primitives
-
-#### Numeric
-
-| Name      	| Type     	| Comments                                                                                                          |
-|-----------	|----------	|------------------------------------------------------------------------------------------------------------------	|
-| FLOAT     	| Constant 	| A 32-bit single-precision floating point number                                                                   |
-| INTEGER   	| Constant 	| A 32-bit signed value in two's complement format, with a minimum value of -2^31 and a maximum value of 2^31-1 	|
-| DOUBLE    	| Constant 	| A 64-bit double-precision floating point number                                                                   |
-| BIG_INT   	| Constant 	| A 64-bit signed INTEGER in two’s complement format, with a minimum value of -2^63 and a maximum value of 2^63 -1  |
-| SMALL_INT 	| Constant 	| A 16-bit signed INTEGER in two’s complement format, with a minimum value of -2^15 and a maximum value of 2^15-1   |
-| TINY_INT  	| Constant 	| A 8-bit signed INTEGER in two’s complement format, with a minimum value of -2^7 and a maximum value of 2^7-1      |
-
-#### Date and time
-
-| Name      	| Type     	| Comments                                                                                                                                                                	|
-|-----------	|----------	|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------	|
-| DATE      	| Constant 	| A date in UNIX format, such as YYYY-MM-DD.                                                                                                                              	|
-| TIMESTAMP 	| Constant 	| Date and time instant in the UNiX format, such as yyyy-mm-dd hh:mm:ss[.f...]. For example, TIMESTAMP '2008-09-15 03:04:05.324'. This format uses the session time zone. 	|
-
-#### String
-
-| Name                                       	| Type     	| Comments                                                                                                                                                                                          	|
-|--------------------------------------------	|----------	|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------	|
-| STRING                                     	| Constant 	| A string literal enclosed in single or double quotes                                                                                                                                              	|
-| decimal(precision: number, scale?: number) 	| Function 	| `precision` is the total number of digits. `scale` (optional) is the number of digits in fractional part with a default of 0. For example, use these type definitions: decimal(11,5), decimal(15) 	|
-| char(length: number)                       	| Function 	| Fixed length character data, with a specified length between 1 and 255, such as char(10)                                                                                                          	|
-| varchar(length: number)                    	| Function 	| Variable length character data, with a specified length between 1 and 65535, such as varchar(10)                                                                                                  	|
-
-#### Miscellaneous
-
-| Name    	| Type     	| Comments                      	|
-|---------	|----------	|-------------------------------	|
-| BOOLEAN 	| Constant 	| Values are `true` and `false` 	|
-| BINARY  	| Constant 	| Value is in binary            	|
-
-### Complex
-
-| Name                                	| Type     	| Comments                                                          	|
-|-------------------------------------	|----------	|-------------------------------------------------------------------	|
-| array(itemType: Type)               	| Function 	| An array of some other type                                       	|
-| map(keyType: Type, valueType: Type) 	| Function 	| A map of some primitive key type to any value type                	|
-| struct(collumns: Column[])          	| Function 	| Nested structure containing individually named and typed collumns 	|
-
-## Data Quality Ruleset
-
-A `DataQualityRuleset` specifies a data quality ruleset with DQDL rules applied to a specified AWS Glue table. For example, to create a data quality ruleset for a given table:
-
-```ts
-new glue.DataQualityRuleset(this, 'MyDataQualityRuleset', {
-  clientToken: 'client_token',
-  description: 'description',
-  rulesetName: 'ruleset_name',
-  rulesetDqdl: 'ruleset_dqdl',
-  tags: {
-    key1: 'value1',
-    key2: 'value2',
-  },
-  targetTable: new glue.DataQualityTargetTable('database_name', 'table_name'),
-});
+});  
 ```
 
-For more information, see [AWS Glue Data Quality](https://docs.aws.amazon.com/glue/latest/dg/glue-data-quality.html).
+## Public FAQ
+
+### What are we launching today?
+
+We’re launching new features to an AWS CDK Glue L2 Construct to provide
+best-practice defaults and convenience methods to create Glue Jobs, Connections,
+Triggers, Workflows, and the underlying permissions and configuration.
+
+### Why should I use this Construct?
+
+Developers should use this Construct to reduce the amount of boilerplate
+code and complexity each individual has to navigate, and make it easier to
+create best-practice Glue resources.
+
+### What’s not in scope?
+
+Glue Crawlers and other resources that are now managed by the AWS LakeFormation
+team are not in scope for this effort. Developers should use existing methods
+to create these resources, and the new Glue L2 construct assumes they already
+exist as inputs. While best practice is for application and infrastructure code
+to be as close as possible for teams using fully-implemented DevOps mechanisms,
+in practice these ETL scripts are likely managed by a data science team who
+know Python or Scala and don’t necessarily own or manage their own
+infrastructure deployments. We want to meet developers where they are, and not
+assume that all of the code resides in the same repository, Developers can
+automate this themselves via the CDK, however, if they do own both.
+
+Validating Glue version and feature use per AWS region at synth time is also
+not in scope. AWS’ intention is for all features to eventually be propagated to
+all Global regions, so the complexity involved in creating and updating region-
+specific configuration to match shifting feature sets does not out-weigh the
+likelihood that a developer will use this construct to deploy resources to a
+region without a particular new feature to a region that doesn’t yet support
+it without researching or manually attempting to use that feature before
+developing it via IaC. The developer will, of course, still get feedback from
+the underlying Glue APIs as CloudFormation deploys the resources similar to the
+current CDK L1 Glue experience.