| --- |
| title: "Spark and Iceberg Quickstart" |
| --- |
| <!-- |
| - Licensed to the Apache Software Foundation (ASF) under one or more |
| - contributor license agreements. See the NOTICE file distributed with |
| - this work for additional information regarding copyright ownership. |
| - The ASF licenses this file to You under the Apache License, Version 2.0 |
| - (the "License"); you may not use this file except in compliance with |
| - the License. You may obtain a copy of the License at |
| - |
| - http://www.apache.org/licenses/LICENSE-2.0 |
| - |
| - Unless required by applicable law or agreed to in writing, software |
| - distributed under the License is distributed on an "AS IS" BASIS, |
| - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| - See the License for the specific language governing permissions and |
| - limitations under the License. |
| --> |
|
|
| ## Spark and Iceberg Quickstart |
|
|
| This guide will get you up and running with an Iceberg and Spark environment, including sample code to |
| highlight some powerful features. You can learn more about Iceberg's Spark runtime by checking out the [Spark](docs/latest/spark-ddl.md) section. |
|
|
| - [Docker-Compose](#docker-compose) |
| - [Creating a table](#creating-a-table) |
| - [Writing Data to a Table](#writing-data-to-a-table) |
| - [Reading Data from a Table](#reading-data-from-a-table) |
| - [Adding A Catalog](#adding-a-catalog) |
| - [Next Steps](#next-steps) |
|
|
| ### Docker-Compose |
|
|
| The fastest way to get started is to use a docker-compose file that uses the [tabulario/spark-iceberg](https://hub.docker.com/r/tabulario/spark-iceberg) image |
| which contains a local Spark cluster with a configured Iceberg catalog. To use this, you'll need to install the [Docker CLI](https://docs.docker.com/get-docker/) as well as the [Docker Compose CLI](https://github.com/docker/compose-cli/blob/main/INSTALL.md). |
|
|
| Once you have those, save the yaml below into a file named `docker-compose.yml`: |
|
|
| ```yaml |
| version: "3" |
| |
| services: |
| spark-iceberg: |
| image: tabulario/spark-iceberg |
| container_name: spark-iceberg |
| build: spark/ |
| networks: |
| iceberg_net: |
| depends_on: |
| - rest |
| - minio |
| volumes: |
| - ./warehouse:/home/iceberg/warehouse |
| - ./notebooks:/home/iceberg/notebooks/notebooks |
| environment: |
| - AWS_ACCESS_KEY_ID=admin |
| - AWS_SECRET_ACCESS_KEY=password |
| - AWS_REGION=us-east-1 |
| ports: |
| - 8888:8888 |
| - 8080:8080 |
| - 10000:10000 |
| - 10001:10001 |
| rest: |
| image: tabulario/iceberg-rest |
| container_name: iceberg-rest |
| networks: |
| iceberg_net: |
| ports: |
| - 8181:8181 |
| environment: |
| - AWS_ACCESS_KEY_ID=admin |
| - AWS_SECRET_ACCESS_KEY=password |
| - AWS_REGION=us-east-1 |
| - CATALOG_WAREHOUSE=s3://warehouse/ |
| - CATALOG_IO__IMPL=org.apache.iceberg.aws.s3.S3FileIO |
| - CATALOG_S3_ENDPOINT=http://minio:9000 |
| minio: |
| image: minio/minio |
| container_name: minio |
| environment: |
| - MINIO_ROOT_USER=admin |
| - MINIO_ROOT_PASSWORD=password |
| - MINIO_DOMAIN=minio |
| networks: |
| iceberg_net: |
| aliases: |
| - warehouse.minio |
| ports: |
| - 9001:9001 |
| - 9000:9000 |
| command: ["server", "/data", "--console-address", ":9001"] |
| mc: |
| depends_on: |
| - minio |
| image: minio/mc |
| container_name: mc |
| networks: |
| iceberg_net: |
| environment: |
| - AWS_ACCESS_KEY_ID=admin |
| - AWS_SECRET_ACCESS_KEY=password |
| - AWS_REGION=us-east-1 |
| entrypoint: > |
| /bin/sh -c " |
| until (/usr/bin/mc config host add minio http://minio:9000 admin password) do echo '...waiting...' && sleep 1; done; |
| /usr/bin/mc rm -r --force minio/warehouse; |
| /usr/bin/mc mb minio/warehouse; |
| /usr/bin/mc policy set public minio/warehouse; |
| tail -f /dev/null |
| " |
| networks: |
| iceberg_net: |
| |
| ``` |
|
|
| Next, start up the docker containers with this command: |
| ```sh |
| docker-compose up |
| ``` |
|
|
| You can then run any of the following commands to start a Spark session. |
|
|
| === "SparkSQL" |
|
|
| ``` sh |
| docker exec -it spark-iceberg spark-sql |
| ``` |
| |
| === "Spark-Shell" |
|
|
| ``` sh |
| docker exec -it spark-iceberg spark-shell |
| ``` |
| |
| === "PySpark" |
|
|
| ``` sh |
| docker exec -it spark-iceberg pyspark |
| ``` |
| |
| !!! note |
|
|
| You can also launch a notebook server by running `docker exec -it spark-iceberg notebook`. |
| The notebook server will be available at [http://localhost:8888](http://localhost:8888) |
| |
| ### Creating a table |
|
|
| To create your first Iceberg table in Spark, run a [`CREATE TABLE`](docs/latest/spark-ddl.md#create-table) command. Let's create a table |
| using `demo.nyc.taxis` where `demo` is the catalog name, `nyc` is the database name, and `taxis` is the table name. |
|
|
|
|
| === "SparkSQL" |
|
|
| ```sql |
| CREATE TABLE demo.nyc.taxis |
| ( |
| vendor_id bigint, |
| trip_id bigint, |
| trip_distance float, |
| fare_amount double, |
| store_and_fwd_flag string |
| ) |
| PARTITIONED BY (vendor_id); |
| ``` |
| |
| === "Spark-Shell" |
|
|
| ```scala |
| import org.apache.spark.sql.types._ |
| import org.apache.spark.sql.Row |
| val schema = StructType( Array( |
| StructField("vendor_id", LongType,true), |
| StructField("trip_id", LongType,true), |
| StructField("trip_distance", FloatType,true), |
| StructField("fare_amount", DoubleType,true), |
| StructField("store_and_fwd_flag", StringType,true) |
| )) |
| val df = spark.createDataFrame(spark.sparkContext.emptyRDD[Row],schema) |
| df.writeTo("demo.nyc.taxis").create() |
| ``` |
| |
| === "PySpark" |
|
|
| ```py |
| from pyspark.sql.types import DoubleType, FloatType, LongType, StructType,StructField, StringType |
| schema = StructType([ |
| StructField("vendor_id", LongType(), True), |
| StructField("trip_id", LongType(), True), |
| StructField("trip_distance", FloatType(), True), |
| StructField("fare_amount", DoubleType(), True), |
| StructField("store_and_fwd_flag", StringType(), True) |
| ]) |
| |
| df = spark.createDataFrame([], schema) |
| df.writeTo("demo.nyc.taxis").create() |
| ``` |
| |
|
|
| Iceberg catalogs support the full range of SQL DDL commands, including: |
|
|
| * [`CREATE TABLE ... PARTITIONED BY`](docs/latest/spark-ddl.md#create-table) |
| * [`CREATE TABLE ... AS SELECT`](docs/latest/spark-ddl.md#create-table--as-select) |
| * [`ALTER TABLE`](docs/latest/spark-ddl.md#alter-table) |
| * [`DROP TABLE`](docs/latest/spark-ddl.md#drop-table) |
|
|
| ### Writing Data to a Table |
|
|
| Once your table is created, you can insert records. |
|
|
| === "SparkSQL" |
|
|
| ```sql |
| INSERT INTO demo.nyc.taxis |
| VALUES (1, 1000371, 1.8, 15.32, 'N'), (2, 1000372, 2.5, 22.15, 'N'), (2, 1000373, 0.9, 9.01, 'N'), (1, 1000374, 8.4, 42.13, 'Y'); |
| ``` |
| |
| === "Spark-Shell" |
|
|
| ```scala |
| import org.apache.spark.sql.Row |
| |
| val schema = spark.table("demo.nyc.taxis").schema |
| val data = Seq( |
| Row(1: Long, 1000371: Long, 1.8f: Float, 15.32: Double, "N": String), |
| Row(2: Long, 1000372: Long, 2.5f: Float, 22.15: Double, "N": String), |
| Row(2: Long, 1000373: Long, 0.9f: Float, 9.01: Double, "N": String), |
| Row(1: Long, 1000374: Long, 8.4f: Float, 42.13: Double, "Y": String) |
| ) |
| val df = spark.createDataFrame(spark.sparkContext.parallelize(data), schema) |
| df.writeTo("demo.nyc.taxis").append() |
| ``` |
| |
| === "PySpark" |
|
|
| ```py |
| schema = spark.table("demo.nyc.taxis").schema |
| data = [ |
| (1, 1000371, 1.8, 15.32, "N"), |
| (2, 1000372, 2.5, 22.15, "N"), |
| (2, 1000373, 0.9, 9.01, "N"), |
| (1, 1000374, 8.4, 42.13, "Y") |
| ] |
| df = spark.createDataFrame(data, schema) |
| df.writeTo("demo.nyc.taxis").append() |
| ``` |
| |
| ### Reading Data from a Table |
|
|
| To read a table, simply use the Iceberg table's name. |
|
|
|
|
| === "SparkSQL" |
|
|
| ```sql |
| SELECT * FROM demo.nyc.taxis; |
| ``` |
| |
| === "Spark-Shell" |
|
|
| ```scala |
| val df = spark.table("demo.nyc.taxis").show() |
| ``` |
| |
| === "PySpark" |
|
|
| ```py |
| df = spark.table("demo.nyc.taxis").show() |
| ``` |
| |
| ### Adding A Catalog |
|
|
| Iceberg has several catalog back-ends that can be used to track tables, like JDBC, Hive MetaStore and Glue. |
| Catalogs are configured using properties under `spark.sql.catalog.(catalog_name)`. In this guide, |
| we use JDBC, but you can follow these instructions to configure other catalog types. To learn more, check out |
| the [Catalog](docs/latest/spark-configuration.md#catalogs) page in the Spark section. |
|
|
| This configuration creates a path-based catalog named `local` for tables under `$PWD/warehouse` and adds support for Iceberg tables to Spark's built-in catalog. |
|
|
| === "CLI" |
|
|
| ```sh |
| spark-sql --packages org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:{{ icebergVersion }}\ |
| --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \ |
| --conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \ |
| --conf spark.sql.catalog.spark_catalog.type=hive \ |
| --conf spark.sql.catalog.local=org.apache.iceberg.spark.SparkCatalog \ |
| --conf spark.sql.catalog.local.type=hadoop \ |
| --conf spark.sql.catalog.local.warehouse=$PWD/warehouse \ |
| --conf spark.sql.defaultCatalog=local |
| ``` |
| |
| === "spark-defaults.conf" |
|
|
| ```sh |
| spark.jars.packages org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:{{ icebergVersion }} |
| spark.sql.extensions org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions |
| spark.sql.catalog.spark_catalog org.apache.iceberg.spark.SparkSessionCatalog |
| spark.sql.catalog.spark_catalog.type hive |
| spark.sql.catalog.local org.apache.iceberg.spark.SparkCatalog |
| spark.sql.catalog.local.type hadoop |
| spark.sql.catalog.local.warehouse $PWD/warehouse |
| spark.sql.defaultCatalog local |
| ``` |
| |
| !!! note |
| If your Iceberg catalog is not set as the default catalog, you will have to switch to it by executing `USE local;` |
| |
| ### Next steps |
|
|
| #### Adding Iceberg to Spark |
|
|
| If you already have a Spark environment, you can add Iceberg, using the `--packages` option. |
|
|
| === "SparkSQL" |
|
|
| ```sh |
| spark-sql --packages org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:{{ icebergVersion }} |
| ``` |
| |
| === "Spark-Shell" |
|
|
| ```sh |
| spark-shell --packages org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:{{ icebergVersion }} |
| ``` |
| |
| === "PySpark" |
|
|
| ```sh |
| pyspark --packages org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:{{ icebergVersion }} |
| ``` |
| |
| !!! note |
| If you want to include Iceberg in your Spark installation, add the Iceberg Spark runtime to Spark's `jars` folder. |
| You can download the runtime by visiting to the [Releases](releases.md) page. |
| |
| <!-- markdown-link-check-disable-next-line --> |
| [spark-runtime-jar]: https://search.maven.org/remotecontent?filepath=org/apache/iceberg/iceberg-spark-runtime-3.5_2.12/{{ icebergVersion }}/iceberg-spark-runtime-3.5_2.12-{{ icebergVersion }}.jar |
|
|
| #### Learn More |
|
|
| Now that you're up an running with Iceberg and Spark, check out the [Iceberg-Spark docs](docs/latest/spark-ddl.md) to learn more! |
|
|
