Upload device_type images via API

[nyevess]

Hi,
I'm doing a big migration from OpenDCIM to Netbox, and I need migrate my device_type images via API, and I have not been able to find a way for doing this.
If this it's possible now, please let me know how to doing.
Thanks!

[nahun]

Doesn't look like there is anyway to do that through the API. The front_image and rear_image properties of a device_type are read only with the API.

[jbemmel]

Now (in 2023) they can be patched

[jmguzmanc]

Hi,
I'm doing a big migration from OpenDCIM to Netbox, and I need migrate my device_type images via API, and I have not been able to find a way for doing this.
If this it's possible now, please let me know how to doing.
Thanks!

I neet the same thing.. If no with the API, is there a automatable mechanism to batch import images to device types?

[candlerb]

I suspect your best bet is to write some Python which talks directly to the Django ORM; you can test this out using nbshell.

Device.front_image and Device.rear_image are of type ImageField, documented here.

[BaconAndEggs]

@nyevess , I suspect I have been walking your path from June 2021 :) I spent the day failing with trying to post device_type images during DeviceType creation via pynetbox api, curl, requests, similarly with ImageAttachements. I won't further detail my adventures in failure unless anyone wants the comedy... You probably already solved this, but here is what I was able to figure out after bumping into this article and seeing @candlerb 's hint on using the shell to write the model directly, here is my hack...

My CI/CD creates new netbox containers often, and during container startup I cp -rf our images to the appropriate devicetype-images dir. Post deployment I have a job use pynetbox to populate regions, sites, tenants, mfgs, and device_types (w/o images of course), etc...
Inside the container startup script I do a little ugly sleep for long enough to make to run after my device_types have been populated.

Here is the ugly code I run to script adding the images (based on the expectation that the containers have the device-type images pre-populated in the convention ${slug}_front.jpeg or ${slug}_rear.jpeg):

import os
from django.core.files import File
print('starting...')

for device_type in DeviceType.objects.all():
    device_type_slug = device_type.slug
    front_registered_image_location = f'/opt/netbox/netbox/media/devicetype-images/{device_type_slug}_front.jpeg'
    if os.path.exists(front_registered_image_location):
        # Check if the image has been registered
        if not device_type.front_image:
            print(f'Registering image {front_registered_image_location} for device_type {device_type_slug}')
            front_image_basename = os.path.basename(front_registered_image_location)
            front_image_tmp_location = f'/tmp/{front_image_basename}'
            os.system(f'mv {front_registered_image_location} {front_image_tmp_location}')
            device_type.front_image.save(name=front_image_basename, content=File(open(front_image_tmp_location, 'rb')))
    rear_registered_image_location = f'/opt/netbox/netbox/media/devicetype-images/{device_type_slug}_rear.jpeg'
    if os.path.exists(rear_registered_image_location):
        # Check if the image has been registered
        if not device_type.rear_image:
            print(f'Registering image {rear_registered_image_location} for device_type {device_type_slug}')
            rear_image_basename = os.path.basename(rear_registered_image_location)
            rear_image_tmp_location = f'/tmp/{rear_image_basename}'
            os.system(f'mv {rear_registered_image_location} {rear_image_tmp_location}')
            device_type.rear_image.save(name=rear_image_basename, content=File(open(rear_image_tmp_location, 'rb')))

print('done')

[jbemmel]

Found another way to do this using Python requests and PATCH through the api: netbox-community/Device-Type-Library-Import#85

def update_images(deviceTypeId,images,src_file):
    url = settings.NETBOX_URL + f"api/dcim/device-types/{deviceTypeId}/"
    headers = { "Authorization": f"Token {settings.NETBOX_TOKEN}" }
    base_dir = os.path.dirname(src_file)

    files = { i: (os.path.basename(f), open(os.path.join(base_dir,f),"rb") ) 
              for i,f in images.items() }
    response = requests.patch(url, headers=headers, files=files)

    print( f'Images {images} updated at {url}: {response}' )

[jsalatiel]

For those wanting full code to do this, I have used @jbemmel idea and came up with this code:

import os
import pynetbox
import requests

NETBOX_URL=''
NETBOX_TOKEN=''

nb = pynetbox.api(NETBOX_URL, token=NETBOX_TOKEN)

def update_images(deviceTypeId,images):
    url = NETBOX_URL + f"api/dcim/device-types/{deviceTypeId}/"
    headers = { "Authorization": f"Token {NETBOX_TOKEN}" }
    files = { i: (os.path.basename(f), open(f,"rb") ) 
              for i,f in images.items() }
    response = requests.patch(url, headers=headers, files=files)
    print( f'Images {images} updated at {url}: {response}' )

all_device_types = {item: item for item in nb.dcim.device_types.all()}
for device_type in all_device_types:
    images = {}
    os.makedirs("images/" + str(device_type), exist_ok=True)
    if os.path.exists("images/" + str(device_type) + "/f.png"):
        images['front_image'] = "images/" + str(device_type) + "/f.png"
    if os.path.exists("images/" + str(device_type) + "/r.png"):
        images['rear_image'] = "images/" + str(device_type) + "/r.png"
    if len(images) > 0:
        print('Uploading images for' + str(device_type))
        update_images(device_type.id, images)

Run it the first time and it will create several directories named as device+type under images sub dir.
For each folder, create f.png(front image) and r.png ( rear image )
Run again and it will upload those files to the correct device_type

Hope it helps

[vsafonin]

I think it's more correct to use '/api/extras/image-attachments' like this:

def _save_image(self, netbox_id: int, image_list: List[Image], content_type: str):
        for image in image_list:
            netbox_image = self._api.extras.image_attachments.get(object_id=netbox_id, name=image.name)
            if not netbox_image:
                header = { "Authorization": f"Token {self._api.token}" }         
                files = { 'image': (image.path, open(image.path, 'rb')) }
                payload = {'name': image.name,
                           'object_id': netbox_id,
                           'content_type': f'{content_type}',
                           'image_height': image.height,
                           'image_width': image.width
                           }
                url = f'{self._api.base_url}/extras/image-attachments/'
                response = requests.post(url, headers=header,
                                        files=files,
                                        data=payload,
                                        verify=False)
                if response.status_code != 201:
                    raise ValueError(f'error on uploading image {response.text}')

Where content_type is something like dcim.location or dcim.device and Image - custom class with fields: name,path, height, width