Asynchronous File Upload With Shrine Local Host

As Ruby on Rail developers, we often run into the need to upload and store images provided by our users.

Often these images demand to be resized and saved as multiple versions: for mobile, spider web, thumbnails, OG images, and other custom and non-standard formats needed past the Customer.

What problem does it atomic number 82 to? Prototype processing is a computationally intensive functioning and the latency will inevitably drop.

Solution? Sidekiq + Shrine!

So… What can be done about it? If you lot are similar me, y'all desire both to have a block and swallow it.

In this blog post, we will go through how to accomplish fast response times while generating multiple versions of an prototype.

The solution is uncomplicated. We volition use Sidekiq to schedule a chore for image processing and immediately return a 200 status response.

For image upload, we will use Shrine. It's a modern library with plugin design and is an alternative to gems like Carrierwave or Paperclip. I similar it very much and recommend using information technology in your projects - it has truly great documentation that cannot be overstated.

How does it piece of work in practice?

Step-by-step Guide

You can see the full application on my Github.

rail new shrine-uploader-api --api --database=postgresql && cd shrine-uploader-api && rail db:create

Add the following to your Gemfile:

And run:

bundle

Allow's utilize a resources generator from Rail CLI. We will create an uploads tabular array with an image_data cavalcade which is essential for Shrine to piece of work:

rails g resource Upload image_data:jsonb && rails db:migrate

We need to configure the Shrine first.

Nosotros volition declare 2 types of storage:

• "cache" for raw images
• "store" for processed images.

In this section, we volition as well declare plugins for integration with ActiveRecord, derivatives generation, and background processing. The last part registers a callback fired on the "promote result". Promote issue is run after our record "Upload" is persisted to the database.

Next, let'due south add together a Shrine uploader with specifications on derivatives we want to generate. Prototype processing is handled underneath by imagemagick:

Let's plug the uploader into our model. Images at present can be accessed through the paradigm virtual field:

We demand to implement a PromoteJob that we used in our initializer. This task will exist put into Redis on the promotion result and later executed in Sidekiq. Here is the code for information technology:

The last thing is to implement a "create action" in the UploadsController.

Boom! We finished with the code!

Now let's run Redis server which Sidekiq uses to store and retrieve jobs. I will use an official docker image merely you can run a Redis from your system if you adopt :)

docker run --name my-redis -d --publish 6379:6379 redis

And run sidekiq:

bundle exec sidekiq

Run Rail server on the other concluding tab:

track s

And there yous go! Our application is functional and running :)

We take an endpoint http://localhost:3000/uploads where we can ship images and they will exist processed co-ordinate to our specifications.

Now permit'south test it!

First, we need an epitome to upload. It can exist any image. In my case, it'south a file I called instance.png

curl -Ten POST -i -F image=@instance.png localhost:3000/uploads

The goal here is to get a 200 response and afterward stop up with iv images in the public/uploads binder: the original image and 3 copies resized according to the rules from ImageUplaoder.

Also, you lot will run across that PromoteJob has been scheduled and successfully run in Sidekiq logs.

At present, let'due south run across how we are doing on the performance side of things.

First, a little flim-flam to get the response fourth dimension from coil. I volition create a file roll-format.txt with the following content and use it later as an statement.

time_total:  %{time_total}southWe volition send our image in the binary form using a -F image=@your-file-name.png flag.

15ms, non bad ;)

I ran some tests without using Sidekiq to asynchronously process images requests and took effectually 120ms. That's 8 times slower than with background processing enabled!

Conclusion

Let's exist honest. Not every Rails awarding needs groundwork image processing.

Only at that place are situations when it is a actually good thought. Imagine building an API where multiple images are uploaded every 2d. Or let's assume y'all do very complex epitome transformations and information technology takes a lot longer than in our case.

In these cases, the delays may become noticeable and this elementary trick I described higher up will surely help you lot keep upward the great performance of your app.

Happy coding!

Piotr is a backend engineer experienced in building Ruby APIs. As an advocate of best engineering science practices, he strives for clean and performant code.

View all author posts

cornwelvere.blogspot.com

Source: https://www.ideamotive.co/blog/asynchronous-image-processing-in-ruby-on-rails-with-shrine