Skip to content
← Newsroom
CloudWorldwide

AWS Glue 6.0 arrives with Spark 4.1, Apache Iceberg v3 support and a 30 percent price cut

Open table formats are becoming the contract between storage and compute, and this release shows why that matters for data pipelines.

Square 1 AI Newsroom5 min read

Amazon Web Services has released AWS Glue 6.0, a new version of its serverless data integration service, the company announced on the AWS News Blog on 21 August. The release is built on Apache Spark 4.1, Python 3.13 and Scala 2.13, and AWS says it is priced 30 percent lower than previous Glue versions. Billing remains hourly, charged by the second, for crawlers and ETL jobs, with a simplified monthly fee for the Data Catalog.

The most significant functional change is full support for the Apache Iceberg v3 table specification, built on Iceberg 1.11.0. Features called out in the post include a VARIANT data type with shredding for storing and querying JSON, logs and event data without flattening the schema, native geometry and geography types for spatial analytics, nanosecond-precision timestamps aimed at IoT and high-frequency financial data, and handling of an unknown type so pipelines can process evolving schemas without failing.

Glue 6.0 also adds Spark Declarative Pipelines, which let engineers describe transformations and leave execution ordering to the engine, and Arrow-native Python user-defined functions and table functions that remove serialisation overhead between Python and the JVM. A real-time streaming mode targets single-digit millisecond latency for stateless streaming workloads.

AWS says the version is generally available in all regions where Glue operates. No API changes are required: existing jobs can select 6.0 through the --glue-version parameter using the AWS CLI, SDKs, Glue Studio or SageMaker Unified Studio, and the company points to an auto-upgrade feature and a Spark upgrade agent to help move existing jobs.

Why it matters

Table formats such as Iceberg have become the shared language that lets many engines read and write the same data on object storage, and cloud providers are now competing on how completely they implement the specification. Newer types like VARIANT and geometry acknowledge that real data is messy, nested and spatial. A price cut alongside a runtime upgrade suggests providers expect volumes to keep growing and are willing to trade margin for adoption. For developers, the lakehouse pattern is becoming the default rather than a specialist choice.

The lakehouse stack a Glue job runs on

Processing engine

Spark jobs, declarative pipelines and streaming tasks that read and write tables.

Table format (Apache Iceberg)

Metadata that tracks snapshots, schema and files so many engines share one table safely.

File format (Parquet)

Columnar files holding the actual rows, compressed and split for parallel reads.

Object storage (Amazon S3)

Durable, cheap blobs with no built-in notion of tables or transactions.

What you can learn from this

  • A table format gives object storage the properties of a database. Object stores such as S3 hold files but know nothing about rows, schemas or transactions. Iceberg adds a metadata layer that records which files belong to a table, what schema they follow and a chain of snapshots representing each commit. Engines coordinate through that metadata, which is how several tools can read and write one table without corrupting it, and how time travel to an earlier snapshot works.

  • VARIANT with shredding keeps flexibility and speed. Semi-structured data like JSON varies from record to record, so forcing it into fixed columns breaks whenever a new field appears. A VARIANT column stores the value in a binary encoding that preserves its structure, while shredding extracts frequently used fields into ordinary columns behind the scenes. Queries on those fields run at columnar speed and rare fields remain queryable without a schema change.

  • Arrow removes a hidden tax on Python. Spark runs on the JVM, and calling a Python function historically meant converting each batch of rows to a format Python understands and back again. Apache Arrow defines a columnar memory layout that both sides can read directly, so data can be handed over without copying or re-encoding. A user-defined function that operates on Arrow batches processes whole columns at once instead of one row at a time, which also lets libraries such as pandas or NumPy apply vectorised operations across the batch.

  • Declarative pipelines separate intent from scheduling. In an imperative script the author decides the order in which tables are built and must handle dependencies manually. A declarative approach lets the author state what each table is derived from, and the engine builds a dependency graph, runs independent steps in parallel and re-runs only what changed. This mirrors how SQL views or build tools such as Make work, and it reduces a common class of ordering bugs.

  • Precision types exist because rounding is data loss. A timestamp stored to the millisecond silently discards detail from a sensor that reports every microsecond, and two events can appear simultaneous when they were not. Nanosecond timestamps and exact geometry types preserve what the source measured. Choosing the type that matches the instrument avoids analytical errors that are very hard to detect after the fact, because once precision is lost at ingestion no downstream query can recover it.

How to use this in practice

  • Stand up a local Iceberg table and time-travel it. Install PySpark on your laptop, add the Iceberg Spark runtime package on the classpath, and create a small table backed by a local directory. Insert rows, update a few, then query the table as of an earlier snapshot using the snapshot ID from the metadata table. Done looks like two query results side by side showing the same table before and after your update, which demonstrates why snapshots matter.

  • Inventory your Glue jobs by runtime version. If you have an AWS account with Glue jobs, run the CLI command aws glue get-jobs and use a --query expression to list each job's name and GlueVersion. If you do not have an account, write the same inventory for any scheduled jobs on your own machine, listing the Python or Spark version each depends on. Done looks like a short table of jobs and versions, with any on older runtimes highlighted as candidates for a test upgrade in a non-production environment.

  • Benchmark a row-wise UDF against an Arrow batch UDF. In a local Spark session, write the same simple transformation twice, once as a plain Python UDF and once as a pandas or Arrow-based UDF, and time each over a few million rows. Use a transformation that is cheap on its own, such as adding two columns, so the measured gap reflects data transfer rather than computation. Done looks like two timings in a notebook cell and a note explaining the difference in terms of serialisation.

  • Draw the lakehouse stack for one of your datasets. Sketch the four layers from object storage through file format and table format to the engines that read it, and label which tool owns each layer in your setup. Done looks like a diagram that makes clear where schema, snapshots and permissions live, and which layer you would change to add a new query engine.

Sources

Our reporting is an original summary; full coverage is at the links above.

Don't just read about it — build it.

Square 1 teaches the skills behind the headlines, with every line of your work graded by AI. Find your starting point in 3 minutes.

Get your free skill report

More in Cloud