1. Create an IAM Role for Redshift:

   - Go to AWS IAM and create a new role.

   - Attach policies that allow Redshift to access S3 (AmazonS3FullAccess or a more restrictive custom policy if needed).

   - Attach this role to your Redshift cluster.

2. Create an S3 Bucket:

   - Go to the AWS S3 service and create a new bucket to store the exported data.

3. Export Data from Redshift:

   - Use the `UNLOAD` command in Redshift to export the data to the S3 bucket.

   - Make sure to choose a suitable file format (CSV, AVRO, Parquet, etc.) for the exported data.

   - Example SQL command:

     ```sql

     UNLOAD ('SELECT * FROM your_table')

     TO 's3://your-bucket-name/exported-data-prefix'

     IAM_ROLE 'arn:aws:iam::your-account-id:role/your-redshift-role'

     FORMAT AS PARQUET;

     ```

1. Configure Databricks CLI:

   - Install the Databricks CLI on your local machine.

   - Configure it using the Databricks workspace token.

2. Mount the S3 Bucket to Databricks:

   - Use Databricks to mount the S3 bucket as a DBFS (Databricks File System) mount point.

   - Use the `dbutils.fs.mount` command in a Databricks notebook:

     ```python

     dbutils.fs.mount(

       source = "s3a://your-bucket-name",

       mount_point = "/mnt/your-mount-point",

       extra_configs = {"fs.s3a.access.key": "your-access-key", "fs.s3a.secret.key": "your-secret-key"}

     )

     ```

1. Create a Databricks Notebook:

   - Create a new Databricks notebook to perform the data import.

2. Read Data from the Mounted S3 Bucket:

   - Use the Databricks DataFrame API to read the data from the DBFS mount point.

   - For example, if you exported the data in Parquet format:

     ```python

     df = spark.read.parquet("/mnt/your-mount-point/exported-data-prefix")

     ```

3. Write Data to Databricks Lakehouse:

   - Decide on the target location in Databricks Lakehouse (Delta Lake).

   - Write the DataFrame to the Delta Lake using the DataFrame API.

   - Example to write data as a Delta table:

     ```python

     df.write.format("delta").save("/mnt/your-delta-table-path")

     ```

4. Create a Table:

   - Optionally, you can create a table that references the Delta files.

   - Use SQL commands in the Databricks notebook:

     ```sql

     CREATE TABLE your_table_name

     USING DELTA

     LOCATION '/mnt/your-delta-table-path'

    ```

1. Validate Data:

   - Run queries against the new table or DataFrame to ensure the data has been transferred correctly.

   - Compare record counts and sample data between Redshift and Databricks.

2. Unmount S3 Bucket (Optional):

   - If you no longer need the S3 bucket mounted to Databricks, unmount it.

   - Use the `dbutils.fs.unmount` command in a Databricks notebook:

     ```python

     dbutils.fs.unmount("/mnt/your-mount-point")

     ```

3. Clean Up S3 Bucket:

   - Remove the exported data from the S3 bucket if it's no longer needed.

1. Automate Data Transfer:

   - If you need to move data regularly, consider automating the process.

   - Use AWS Data Pipeline, AWS Lambda, or other AWS services to schedule and run the Redshift `UNLOAD` command.

   - Use Databricks Jobs to schedule data import into Databricks Lakehouse.

By following these steps, you can successfully transfer data from Amazon Redshift to Databricks Lakehouse without the need for third-party connectors or integrations. Always ensure that you are following best practices for security and data governance when transferring data between systems.