
import BlogPostLayout from '../../../components/blog/BlogPostLayout'
import Meta from '../../../components/blog/Meta'

<Meta
  title="Automatically migrate Images from Airtable to a CDN"
  description="Airtable image links will be expiring after 2 hours. This script will automatically migrate all images to a CDN of your choice."
  keywords={['python', 'airtable', 'cdn']}
></Meta>

<BlogPostLayout>
# Automatically migrate Images from Airtable to a CDN

Are your Airtable images disappearing after just two hours?
Airtable [recently changed their attachment URL behavior](https://support.airtable.com/docs/airtable-attachment-url-behavior),
causing them to expire after 120 minutes. If you're using these URLs to display images on your website, you might be wondering what to do next.
The solution? Migrate all your images to a CDN of your choice.

Not only will this fix the problem, but it can also speed up your site and reduce hosting costs.
In this blog post, I'll show you how to automatically migrate your Airtable images to a CDN using Python and bunny.net as an example CDN.

Let's get started!

## The Idea

To summarize, the steps to automatically migrate your Airtable images to a CDN are as follows:

1. Download all your images from Airtable to your local machine.
2. Optionally, optimize and resize the images to improve loading speed.
3. Upload the images to a CDN of your choice, such as [bunny.net](https://bunny.net).
4. Update the URLs in your Airtable records to point to the newly uploaded images.

## The Script

The following script will automatically download all the images from airtable, resize and optimize them, upload them to a CDN and update the airtable records with the new image URLs:

```python
from pyairtable import Table
import requests
import shutil
from BunnyCDN.Storage import Storage
import os
import tinify

# LOCAL CONFIG
BASE_PATH = '<path-on-your-local-machine>'

# AIRTABLE CONFIG
API_KEY = '<your-airtable-api-key>'
BASE_ID = '<your-airtable-base-id>'
TABLE_NAME = '<your-table-name>'
IMAGE_FIELD = '<your-image-field-name>'
IMAGE_URL_FIELD = '<your-image-url-field-name>'

# TINIFY CONFIG
tinify.key = "<your-tinify-api-key>"

# BUNNY CDN CONFIG
BASE_BUNNY_URL = '<base-path-of-your-cdn>'
BUNNY_STORAGE_CONFIG = {
    "api_key": "<your-bunny-api-key>",
    "zone_name": "<your-bunny-zone-name>",
    "zone_region": "<your-bunny-zone-region>"
}
BUNNY_STORAGE_CLIENT = Storage(
    BUNNY_STORAGE_CONFIG["api_key"],
    BUNNY_STORAGE_CONFIG["zone_name"],
    BUNNY_STORAGE_CONFIG["zone_region"]
)

def upload_file(client, filename, storage_path, local_upload_file_path=None):
    return client.PutFile(
        filename,
        storage_path=storage_path,
        local_upload_file_path=local_upload_file_path
    )

def download_image_from_airtable(record):
  url = record["fields"][IMAGE_FIELD][0]["url"]
  name_slug = record["fields"]["name"].replace("-", "").replace("  ", " ").replace(" ", "_").replace("!", "").lower()
  img_type = record["fields"][IMAGE_FIELD][0]["type"].split("/")[1]

  file_name = "%s_img.%s" % (name_slug, img_type)
  path = '%s/%s' % (BASE_PATH, name_slug)
  full_path = '%s/%s' % (path, file_name)

  if not os.path.exists(path):
    os.makedirs(path)

  res = requests.get(url, stream = True)

  if res.status_code == 200:
      with open(full_path,'wb') as f:
        shutil.copyfileobj(res.raw, f)

      try:
        source = tinify.from_file(full_path)
        converted = source.convert(type=["image/webp"])
        extension = converted.result().extension

        file_name =  "%s_image.%s" % (name_slug, extension)
        converted.to_file("%s/%s" % (path, file_name))
      except Exception as e:
        print(e)
        pass

      print('Image sucessfully Downloaded: ',file_name)
  else:
      print('Image Couldn\'t be retrieved')

  return name_slug, file_name

def upload_image_to_bunny_cdn( folder_name, file_name):
  upload_file(
    BUNNY_STORAGE_CLIENT,
    file_name,
    '%s/%s' % (folder_name, file_name),
    '%s/%s' % (BASE_PATH, folder_name)
  )

  print("--- Image successfully uploaded ---")

def update_airtable_image_url(record, name_slug, file_name):
  table.update(record["id"], {IMAGE_URL_FIELD: BASE_BUNNY_URL + name_slug + "/" + file_name})

if __name__ == "__main__":
  table = Table(API_KEY, BASE_ID, TABLE_NAME)
  all_records = table.all();

  for record in all_records:
    image_slug, image_file_name = download_image_from_airtable(record)
    upload_image_to_bunny_cdn(image_slug, image_file_name)
    update_airtable_image_url(record, thumbnail_slug, thumbnail_file_name)

```

In the following sections, I will explain each part of the script in detail.

### Downloading the Images from Airtable

To automatically download all your images from airtable, you can use
[pyairtable](https://pyairtable.readthedocs.io/en/latest/getting-started.html) -
A python wrapper arround the airtable API. With this, you can easily configure your table with:

```python
table = Table(API_KEY, BASE_ID, TABLE_NAME)
```

To download an image, you'll need to provide the column name of the image field. Then you can get the url from it and download it manually:

```python
def download_image_from_airtable(record):
  url = record["fields"][IMAGE_FIELD][0]["url"]
  img_type = record["fields"][IMAGE_FIELD][0]["type"].split("/")[1]

  res = requests.get(url, stream = True)
```

### Automatically Optimizing the images

If you want to optimize the images before uploading them to the CDN, you can use the [tinypng api](https://tinypng.com/developers/reference).
This allows you to simply call the `from_file` method to load a file and convert and optimize it with the `convert` method:

```python
source = tinify.from_file(full_path)
converted = source.convert(type=["image/webp"])
extension = converted.result().extension

file_name =  "%s_image.%s" % (name_slug, extension)
converted.to_file("%s/%s" % (path, file_name))
```

In this case I'm converting the image to webp to save even more space.

### Uploading the Images to a CDN

This step is optional and will depend on the CDN you're using. In my case, I'm using [bunny.net](https://bunny.net) and bunny provides
me with [an API](https://github.com/mathrithms/BunnyCDN-Python-Lib) so that I don't have to upload the images manually.
You can simply call:

```python
upload_file(
  BUNNY_STORAGE_CLIENT,
  file_name,
  '%s/%s' % (folder_name, file_name),
  '%s/%s' % (BASE_PATH, folder_name)
)
```

Check out [the documentation](https://github.com/mathrithms/BunnyCDN-Python-Lib) for more information on how to use the bunny API.

### Updating the Airtable records with the new image URLs

The last step is to update the airtable records with the new image URLs. This is done by calling:

```python
def update_airtable_image_url(record, name_slug, file_name):
  table.update(record["id"], {IMAGE_URL_FIELD: BASE_BUNNY_URL + name_slug + "/" + file_name})
```

Note that you will need to choose a column which already exists in you airtable for `IMAGE_URL_FIELD`, otherwise you will get an error.

### Conclusion

In conclusion, migrating your Airtable images to a CDN can save you from the hassle of constantly updating attachment URLs
and provide a faster and more reliable website for your visitors. With the use of Python and an
example CDN like bunny.net, it's easier than ever to automate this process and ensure that your
images are always accessible. By following the steps outlined in this blog post, you'll be able to
migrate your images to a CDN with ease and enjoy the benefits of a faster and more secure website.

</BlogPostLayout>
