O que vamos aprender?
o ActiveStorage é um novo recurso que veio na versão 5.2 do Rails para facilitar o upload de arquivos, e nós vamos aprender como utiliza-lo na prática (criando um pequeno projeto).
- Como fazer upload de arquivos com o ActiveStorage
- Como deixar nossos uploads assíncronos (com indicador de progresso)
- Como enviar nossos arquivos direto para o S3 da Aws
- Como gerar variações das nossas imagens
Bora?
Ferramentas
- Ruby 2.4.2
- Rails 5.2.0
- ActiveStorage (parte do Rails 5.2)
- ImageMagick (software para modificar imagens)
Resumo do app
Neste artigo vamos criar um pequeno App onde os usuários poderão compartilhar arquivos entre si de maneira organizada através do upload de arquivos para repositórios (buckets).
Para fazer isso vamos criar as seguintes features:
- Criação de um bucket
- Remoção de um bucket
- Upload de novos arquivos para um bucket
- Remoção de um arquivo
- Download de um arquivos
Projeto desenvolvido no Github: https://github.com/OneBitCodeBlog/awesome_bucket
Então, vamos começar a codar! \o/
Mãos a obra
Preparação
Primeiro, vamos criar nosso app e destacar algumas coisas a respeito do ActiveStorage
1. Para instalar Rails 5.2.0, vamos executar no terminal
|
1 |
gem install rails -v '5.2.0' |
2. Crie o projeto rodando o comando a seguir (e depois entre na pasta dele):
|
1 |
rails new awesome_bucket |
3. Para instalar o Active Storage (gerar a migration dele) rode no console:
|
1 |
rails active_storage:install |
4. Agora vamos entrar no diretório do app
|
1 |
cd awesome_bucket |
5. Para saciar a curiosidade, vamos abrir o arquivo de migration to ActiveStorage, ele contém (db/migrate/<datetime>_create_active_storage_tables.active_storage.rb):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
class CreateActiveStorageTables < ActiveRecord::Migration[5.2] def change create_table :active_storage_blobs do |t| t.string :key, null: false t.string :filename, null: false t.string :content_type t.text :metadata t.bigint :byte_size, null: false t.string :checksum, null: false t.datetime :created_at, null: false t.index [ :key ], unique: true end create_table :active_storage_attachments do |t| t.string :name, null: false t.references :record, null: false, polymorphic: true, index: false t.references :blob, null: false t.datetime :created_at, null: false t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_active_storage_attachments_uniqueness", unique: true end end end |
Olhe o que o AS faz: Cria duas tabelas, uma para armazenar as informações do arquivo (nome, tipo de conteúdo etc) e outro para armazenar as informações a respeito do model que contém os arquivos.
Eu sei que estas “informações a respeito do model que contém arquivos” ficou um pouco confuso, mas vamos entender melhor daqui a pouco com código =)
6. Além destas tabelas o active storage vem com uma arquivo de configuração em config/storage.yml:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
test: service: Disk root: <%= Rails.root.join("tmp/storage") %> local: service: Disk root: <%= Rails.root.join("storage") %> # Use rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key) # amazon: # service: S3 # access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %> # secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %> # region: us-east-1 # bucket: your_own_bucket |
7. E com esta linha configurada em development.rb (config/environments/development.rb)
|
1 2 |
# Store uploaded files on the local file system (see config/storage.yml for options) config.active_storage.service = :local |
O arquivo storage.yml é usado para informar ao ActiveStorage onde ele vai armazenar o seu arquivo. Inicialmente ele vem configurado localmente para a pasta storage na raiz do seu projeto e na pasta tmp/storage para testes.
O conteúdo do arquivo development.rb foi exibido para vermos que, por padrão, ele seleciona o storage de nome local para utilizar no upload. Podemos colocar esta mesma linha em test.rb e production.rb, conforme o que quisermos configurar em cada ambiente.
Há algumas linha comentadas no storage.yml neste snippet. Exibí estas linhas porque o ActiveStorage já vem preparado para upload em serviços cloud Amazon S3, Azure e Google Cloud Services. Mas, vamos começar utilizando o armazenamento local.
Agora vamos à estrutura do app.
Criando a estrutura do app
1. Primeiro, vamos criar um scaffold para o Bucket
|
1 |
rails g scaffold Bucket name |
2. Rodar os migrations
|
1 |
rails db:migrate |
3. No model Bucket, adicionaremos a seguinte linha (app/models/bucket.rb):
|
1 |
has_many_attached :files |
4. E colocaremos o rota raiz para o index do BucketsController (config/routes.rb):
|
1 |
root to: "buckets#index" |
Nesta parte simplesmente foi criado um scaffold para o nosso bucket, executado as migrations e, por fim adicionamos o has_many_attached, que é o que vai dizer que o nosso model Bucket possuirá anexos e terá o nome de :files. Por último, colocamos a nossa rota principal como sendo a action :index do BucketsController criado com o scaffold.
Era nesse ponto que eu queria chegar para explicar melhor como ActiveStorage está trabalhando com o nosso model.
O que ocorreu no model Bucket?
Bem, quando colocamos em nosso model o has_many_attached :files, um atributo chamado :files é criado e recebe um objeto do tipo ActiveStorage::Attached. Este objeto juntamente com os models ActiveStorage::Blob, ActiveStorage::Attachment e outros é que o vai nos prover uma imensa gama de funcionalidades e facilidades para usar o AS.
No lugar de has_many_attached, também poderíamos ter usado o has_one_attached :file, para que o model Bucket tenha apenas um anexo. Ou seja, no lugar de termos uma lista de anexos, haveria apenas um.
Criando um formulário de Upload
Com o scaffold, as ações de CRUD do Bucket foram criadas sem problemas.
Agora vamos criar um controller que será responsável por recepcionar os uploads e associá-los ao Bucket. Então, vamos aos códigos 🙂
1. O primeiro passo um controller com a action new que será utilizada para renderizar o formulário de upload
|
1 |
rails g controller file_uploads new |
2. Vamos ajustar a nossa rota para o controller FileUploads (config/routes.rb):
Primeiro vamos remover o registro criado pelo generator que é este conteúdo:
|
1 |
get 'file_uploads/new' |
Depois colocar o :file_uploads como rota aninhada (nested route) das rotas do Bucket, ficando desta forma:
|
1 2 3 |
resources :buckets do resources :file_uploads, only: [:new, :create] end |
Deixado o nosso arquivo de rotas desta forma:
|
1 2 3 4 5 6 |
Rails.application.routes.draw do root to: "buckets#index" resources :buckets do resources :file_uploads, only: [:new, :create, :destroy] end end |
Perceba que no resources do :file_uploads, foram colocadas três actions: :new, :create e :destroy. A :create será responsável por recepcionar os arquivos que forem enviados pelo formulário renderizado na action :new. E a :destroy, para remover um arquivo.
3. Como temos uma rota aninhada, vamos precisar carregar também o Bucket na action :new.
Em FileUploadsController, a action :new ficará da seguinte forma (app/controllers/file_uploads_controller.rb):
|
1 2 3 |
def new @bucket = Bucket.find(params[:bucket_id]) end |
4. Por último, criaremos um formulário para a action :new (app/views/file_uploads/new.html.erb):
|
1 2 3 4 5 6 7 |
<h1>Upload for Bucket <%= @bucket.name %></h1> <%= form_with model: @bucket, url: bucket_file_uploads_path(@bucket), method: :post, local: true do |f| %> <%= f.file_field :files, multiple: true %><br /><br /> <%= f.submit 'Upload' %> <% end %> |
Perceba que no formulário há apenas o campo de upload e um botão para submit. Neste campo upload, estamos utilizando um helper file_field do Rails para renderizar um campo de anexo. Precisamos também da URL, já que não é um rota padrão do model Bucket, e setar local: true para que o formulário seja enviado de forma síncrona. Lembrando que não é obrigatório que o formulário seja síncrono, colocamos esta configuração apenas para acompanharmos o submit do formulário sem a necessidade de utilizar outros recursos.
Com este passo feito, agora podemos criar o código para recepcionar os arquivos enviados pela action :new.
Recepcionando os arquivos
Para recepcionar os arquivos, vamos criar uma action :create com os passos para receber arquivos no controller FileUploads, alterar a view :show do Bucket para listar os arquivos adicionados e adicionar um link para enviar mais arquivos
1. Criaremos a action :create no FileUploadsController com o seguinte conteúdo (app/controllers/file_uploads_controller.rb)
|
1 2 3 4 5 |
def create @bucket = Bucket.find(params[:bucket_id]) @bucket.files.attach(params[:bucket][:files]) redirect_to bucket_path(@bucket) end |
Olha como o ActiveStorage já adiantou nosso trabalho: ao usar o has_many_attached :files, o atributo :files, agora sendo acompanhado pelo ActiveStorage, tornou disponível, dentre outros, o método :attach. Para chamar este método, podemos passar diretamente o parâmetro que foi recebido do formulário, sem a necessidade de nenhuma alteração.
2. Vamos deixar a view :show do Bucket da seguinte forma (app/views/buckets/show.html.erb):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
<p id="notice"><%= notice %></p> <h3><%= @bucket.name %></h3> <%= link_to 'Edit', edit_bucket_path(@bucket) %> | <%= link_to 'Back', buckets_path %> | <%= link_to 'Upload Files', new_bucket_file_uploads_path(@bucket) %> <h5>Files</h5> <ul> <% @bucket.files.each do |file| %> <li><%= link_to file.filename, url_for(file) %></li> <% end %> </ul> |
Nesta view, adicionamos alguns itens a mais: um botão que vai nos direcionar para a página onde fazemos um upload e uma lista de arquivos que aquele Bucket já tem. Perceba que dentro do link_to utilizamos mais duas coisas: file.filename, para acessar o nome do arquivo e um método url_for que recebe como parâmetro um registro do :files do model Bucket e já retorna uma url para o arquivo.
Removendo um arquivo enviado
O AS também traz um meio de removermos facilmente um arquivo que foi anexado atrávés do método :purge que é chamado também no objeto de anexo, no nosso caso com o nome :files.
Para podemos remover o arquivo, faremos o passo-a-passo abaixo
1. Apenas relembrando, já temos uma rota para o :destroy do FileUploadsController (config/routes.rb):
|
1 |
resources :file_uploads, only: [:new, :create, :destroy] |
2. Agora vamos criar a action :destroy no nosso controller de FileUpload (app/controllers/file_uploads_controller.rb):
|
1 2 3 4 5 |
def destroy @bucket = Bucket.find(params[:bucket_id]) @bucket.files.find(params[:id]).purge redirect_to bucket_path(@bucket) end |
3. Por último, vamos adicionar um “X” na frente do nosso arquivo para que possamos clicar e remover. Para isso, a view :show do Bucket ficará da seguinte forma (app/views/buckets/show.html.erb):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
<p id="notice"><%= notice %></p> <h3><%= @bucket.name %></h3> <%= link_to 'Edit', edit_bucket_path(@bucket) %> | <%= link_to 'Back', buckets_path %> | <%= link_to 'Upload Files', new_bucket_file_uploads_path(@bucket) %> <h5>Files</h5> <ul> <% @bucket.files.each do |file| %> <li> <%= link_to file.filename, url_for(file) %> <%= link_to "X", bucket_file_upload_path(@bucket, file), method: :delete, data: { confirm: "Tem certeza?" } %> </li> <% end %> </ul> |
E está pronta a exclusão. Agora toda vez que houver um arquivo e clicarmos no “X”, aparecerá uma mensagem de confirmação e ele será excluído.
Ah, uma curiosidade. O AS também vem com uma função chamada :purge_later que podemos usar igual o :purge, mas em vez de excluir instantaneamente, ela vai iniciar um Job do Rails que vai fazer o trabalho. É uma funcionalidade muito interessante para excluir arquivos grandes ou até mesmo de algum serviço na nuvem.
*Para saber mais sobre Jobs: Dominando o uso de Jobs no Rails
Bem, galera, está completo o básico nosso app \o/, agora bora dar um start no server com rails s e testar =D
Trabalhando com Imagens no AS
Uma das facilidades que o ActiveStorage nos oferece vem de uma ferramenta chamada ImageMagick. Com ela é possível fazer transformações de um arquivo de imagem como por exemplo redimensionar seu tamanho.
Como ele nos oferece isso? É bem simples, existe a gem MiniMagick que se conecta ao ImageMagick instalado no sistema para alterar as imagens. Para integrar isso com o ActiveStorage nós utilizamos um recurso chamado variants.
Primeiro, vamos instalar a gem Mini Magick. Adicione no seu Gemfile:
|
1 |
gem 'mini_magick' |
*Lembrando que você precisa ter o imageMagick instalado
Agora vamos instalar
|
1 |
bundle install |
Vamos usar como exemplo o código que adicionamos na view :show do Bucket (app/views/buckets/show.html.erb):
|
1 2 3 4 5 6 |
<% @bucket.files.each do |file| %> <li> <%= link_to file.filename, url_for(file) %> <%= link_to "X", bucket_file_upload_path(@bucket, file), method: :delete, data: { confirm: "Tem certeza?" } %> </li> <% end %> |
Se quiséssemos usar os variants, poderíamos fazer este código da seguinte forma:
|
1 2 3 4 5 6 |
<% @bucket.files.each do |file| %> <li> <%= link_to file.blob.filename, url_for(file.variant(resize: "120x120")) %> <%= link_to "X", bucket_file_upload_path(@bucket, file), method: :delete, data: { confirm: "Tem certeza?" } %> </li> <% end %> |
O que este file.variant faz, na verdade, é pegar a imagem original e redimensionar (:resize) para o tamanho que eu especifiquei. Dentro do variant há diversas outras opções a serem utilizadas.
Mas, cuidado!! Se vc tentar utilizar variant num arquivo que não seja do tipo imagem, um erro vai ser gerado no seu app.
E para não ficarmos limitados a usar apenas imagens, por causa do variant, voltaremos view :show como estava antes, sem o variant:
|
1 2 3 4 5 6 |
<% @bucket.files.each do |file| %> <li> <%= link_to file.filename, url_for(file) %> <%= link_to "X", bucket_file_upload_path(@bucket, file), method: :delete, data: { confirm: "Tem certeza?" } %> </li> <% end %> |
O Direct Upload
Imagine que incrível seria podermos fazer o upload de um arquivo de forma assíncrona pro nosso servidor e melhor, podermos acompanhar o progresso de upload.
Bem, agora podemos!
O AS veio com uma funcionalidade incrível chamada Direct Upload. Quando utilizamos esta funcionalidade, ao darmos um submit no formulário, todos os arquivos serão enviados e salvos no servidor de forma assíncrona e só depois que o upload for concluído que o formulário será, de fato, enviado.
E fazer isso é muito, muuito fácil,
Então vamos pra melhor parte: codar!
Vamos seguir um passo a passo para configurar o Direct Upload para usarmos localmente:
1. Primeiro, vamos instalar a gem jquery-rails para facilitar o bind de eventos. Para isso, adicionaremos a gem jquery-rails ao seu Gemfile
|
1 |
gem 'jquery-rails' |
2. Importaremos o jquery no application.js, que ficará da seguinte forma (app/assets/javascripts/application.js):
|
1 2 3 4 5 |
//= require jquery //= require rails-ujs //= require activestorage //= require turbolinks //= require_tree . |
3. Depois, abriremos a view de upload e substituiremos o código pelo que está abaixo (app/views/file_uploads/new.html.erb):
|
1 2 3 4 5 6 7 8 |
<h1>Upload for Bucket <%= @bucket.name %></h1> <h4 class="progress" style="display: none">Progress: <span class="progress_count"></span>%</h4> <%= form_with model: @bucket, url: bucket_file_uploads_path(@bucket), method: :post, id: "upload_file", local: true do |f| %> <%= f.file_field :files, multiple: true, direct_upload: true %><br /><br /> <%= f.submit 'Upload' %> <% end %> |
Nesta view de upload, foi adicionado um h4 que será utilizado para mostrar o progresso de upload (sim, podemos fazer isso com o direct upload :D) e, além disso, adicionamos um direct_upload: true no input file.
Esta view, da forma como está, já está com o Direct Upload habilitado e funcionando. Ela já está enviado o arquivo antes de submeter o formulário como um todo (você pode checar nos logs do server). Mas como queremos trazer mais conteúdo, seguiremos adiante 🙂
4. Adicionaremos seguinte script ao application.js (app/assets/javascripts/application.js):
|
1 2 3 4 5 6 7 8 9 |
$(document).on("turbolinks:load", function(){ $("#upload_file").on("direct-uploads:start", function(){ $("h4.progress").show(); }); $("#bucket_files").on("direct-upload:progress", function(event){ $("h4.progress span.progress_count").html(event.detail.progress); }); }); |
Ao colocamos direct_upload: true num campo de anexo de arquivos (input file), o javascript do Active Storage se encarrega de colocar vários eventos no formulário e no campo de anexo de arquivo que sao invocados no momento do submit.
Um deles é o direct-uploads:start que está no próprio formulário, que é chamado logo quando clicamos no botão para dar o submit no formulário. Utilizamos para poder exibir o campo h4 onde mostraremos o progresso do upload.
O outro evento que estamos utilizamos é o direct-upload:progress que está no próprio campo de anexo e é chamado conforme o arquivo vai sendo enviado para o servidor. A cada progresso que o arquivo faz, este evento é chamado e a porcentagem do progresso vem dentro de event.detail.progress, cujo valor colocamos direto no span do h4.
É necessário utilizar o event.detail.progress porque o progresso é enviado dentro dos detalhes do próprio evento.
P.S.: nas documentações do AS, tem uma lista de todos os eventos usado para o Direct Upload. E todos utilizam este mesmo formato de resultado como detalhes do event.
E a cereja do Bolo: Upload DIRETO para a Nuvem
Para fazer um upload direto pra nuvem, sem que o arquivo passe pelo nosso servidor antes, é bem simples.
Primeiro, é necessário habilitar o direct upload no campo de anexo. E nós já fizemos isso no passo anterior. Agora, apenas o que precisaremos fazer é configurar o nosso storage para fazer um upload para algum serviço de cloud.
Nesta demonstração, vamos utilizar um exemplo de upload para o Amazon S3.
1. Primeiro, será necessário que você crie uma conta na Amazon.
2. Depois, você terá que ir até o serviço Amazon S3 e criar um bucket com o nome que desejar. No nosso caso, criamos o bucket com nome onebitcode em umas das regiões.
3. É necessário que você mude as configurações de CORS na aws para permitir o upload vindo da sua URL.
4. Depois adicionaremos a gem da AWS para o S3 no Gemfile:
|
1 |
gem 'aws-sdk-s3' |
5. Instalaremos a gem rodando:
|
1 |
bundle install |
6. As informações necessárias para upload no AmazonS3 são: Access Key, Secret Key, region e nome do bucket. Vamos adicionar estas informações no storage.yml da seguinte forma (config/storage.yml):
|
1 2 3 4 5 6 |
amazon: service: S3 access_key_id: <minha access key> secret_access_key: <minha secret key> region: <minha region> bucket: onebitcode |
Neste arquivo, criamos um storage com nome amazon, que utilizará o serviço S3 (nome padrão do AS), com as informações secret_key_id, secret_access_key e region (adicionar as suas) para fazer uploads no bucket onebitcode.
7. Nosso último passo, informaremos ao Rails que queremos utilizar este storage fazendo a seguinte alteração nas configurações de desenvolvimento (config/environments/development.rb):
Substituindo a seguinte linha
|
1 2 |
# Remover esta linha config.active_storage.service = :local |
Por esta:
|
1 |
config.active_storage.service = :amazon |
Nesta configuração em development.rb, estamos dizendo para o Rails utilizar no ambiente de development o storage com nome amazon. Mas o interessante seria aplicar esta alteração somente em produção (production.rb) para que não seja cobrado a utilização ao fazer uploads apenas para fins de teste.
8. Reiniciar o seu servidor e testar o/
Não perca nenhum conteúdo
Receba nosso resumo semanal com os novos posts, cursos, talks e vagas o/
Conclusão
O ActiveStorage veio como uma solução incrível para que possamos finalmente relaxar um pouco quando formos tratar de upload de arquivos (Ufa!). Creio que a ferramenta por ser nova, ainda tenha um caminho pela frente, mas com estes recursos que acabamos de ver e que já estão no forno pronto pra sair na próxima versão do Rails já podemos ver que é uma solução que veio pra ficar. (o alívio é grande).
E não esqueçam de ler o README do ActiveStorage e montar soluções incríveis com soluções locais ou em nuvem =D
Tem também o repositório do app que criamos no post:
https://github.com/OneBitCodeBlog/awesome_bucket
Obs: Galera, o has_many_attached e o has_one_attached criam uma associação entre o model do nosso app e os models do AS. Então, se excluirmos um Bucket agora, além dele, todos os registros dos arquivos e os próprios arquivos físicos serão excluídos. Resumindo, ele funciona como um depedent: :destroy das associações do Rails. E isso vale tanto para o storage local quanto para o storage na nuvem. Bem legal né?
É isso aí, galera! Qualquer dúvida, estamos a disposição para ajudar! : )
Nos vemos no próximo conteúdo!
Primeira vez no OneBitCode? Curtiu esse conteúdo?
O OneBitCode tem muito mais para você!
O OneBitCode traz conteúdos de qualidade, e em português, sobre programação com foco em Ruby on Rails e também JavaScript.
Além disso, aqui sempre levamos à você conteúdos valiosos sobre a carreira de programação, dicas sobre currículos, portfólios, perfil profissional, soft skills, enfim, tudo o que você precisa saber para continuar evoluindo como Programador(a)!
Fique por dentro de todos os conteúdos o/
Nossas redes sociais:
📹 • https://youtube.com/Onebitcode [Live todas as terças-feiras às 19h)
💻 • https://linkedin.com/company/onebitcode
🙂 • best dating apps for young adults
📱 • 50 cent is dating my mom
🐦 • https://twitter.com/onebitcode
Nossos cursos:
🥇 • Programador Full Stack Javascript em 8 Semanas
💎 • Curso Completo de Ruby
⚙ • Minicurso: API Rails 5 Completo
🐞 • Minicurso de Testes para Ruby on Rails com RSpec
Espero que curta nossos conteúdos e sempre que precisar de ajuda, fala com a gente!
Estamos aqui para você 🙂
Bem-vindo à família OneBitCode o/
Leo, sugiro corrigir a informação com a instrução para baixar o Rails na versão beta2:
gem install rails -v ‘5.2.0.beta2’
No seu tá faltando o zero.
Snippet com a instalação da gem corrigido.
Obrigado, Alex!
Parabéns Moreto, ótimo post.
Abs
Obrigado, Fabiano! : )
Abraço
Muito bom o post!
Opa, valeu por acompanhar Lucas 🙂
Tem um erro, aonde tu edita o show.html.erb.
Se colocar como tu mandou “bucket_file_upload_path” da erro de rotas.
O correto é “bucket_file_uploads_path”. uploads no plural.
Na parte do Direct Upload, tem um erro no codigo JS. Esta assim:
$(“h4.progress span.progress_count”).html(event.detail.progress);
O que gera um erro de sintaxe ao executar. Tirando, funciona dai:
$(“h4.progress span.progress_count”).html(event.detail.progress);
O problema é esse perdido ali no meio. Fácil de resolver, mas quem não entende se perde facil.
E isso acontece nas duas linhas que tem o h4.progress.
No meu ultimo comentario, pelo visto, pegou a tag do problema pra formatar o texto em HTML.
Eu nao consigo editar o comentario, então se puderem arrumar, é a tag de bold .
Opa, Jean!
Corrigido! Muito obrigado pelo toque.
Boa noite. Muito boa a publicação, parabéns.
Tenho uma duvida de como pegar a url do arquivo anexo e passar para um retorno de um JSON da API.
Tenho a classe Account, adicionei o has_one_attached :logo, tentei de varias formar pegar a URL do arquivo anexo mas não consegui, todos os exemplos mostra usando HTML, eu preciso apenas retornar para o JSON.
Tem alguma dica?
Opa, Sérgio! Boa noite!
Então, encontrei um workaround pra resolver o seu problema por hora.
Utilize o código abaixo enviando em
fileo arquivo que vc está carregando e quer enviar e emfilenameum nome para o arquivo.Rails.application.routes.url_helpers.rails_service_blob_path(file, filename: <nome para o arquivo)Uma pergunta, vc está utilizando alguma ferramenta para serializar o JSON?
Excelente tutorial!
Estou querendo implementar em uma aplicação minha que é apenas API, é possível normalmente certo?
Tem que mudar alguma configuração ou pode seguir o tutorial e fazer normalmente um POST com as imagens por exemplo?
Ótimo post. Não encontrei nenhuma informação sobre download remoto, similar ao que o CarrierWave faz.
Passar a url direto pro campo file, mandar salvar e pronto. Exemplo:
objeto.remote_imagem_url = “http://www.site.com/imagem.jpg”
objeto.save!
É possível algo assim com o ActiveStorage? Valeu…
Como faco para enviar para o servidor do google?
Opa!
Nas docs do AS tem as configs para Google Cloud.
https://edgeguides.rubyonrails.org/active_storage_overview.html#google-cloud-storage-service
Qualquer duvida, só chamar a gente! 🙂
coloquei essas configurações mesmo assim continua dando erro. Vc nao tem um tutorial explicando passo a passo?
Não precisa mais. Fiz aq.