DEV Community: David Muñoz

Fixing the ElevenLabs Call Transfer Bug with Twilio

David Muñoz — Wed, 01 Oct 2025 15:53:38 +0000

A note on frustration

For more than three months, I’ve been reporting this bug to ElevenLabs, along with several other developers who have asked for a fix. Unfortunately, it hasn’t been resolved, and the only practical way forward is to apply this kind of workaround.

It’s frustrating to patch around such a core issue, but until it’s fixed, this manual solution is the only way to deliver a smooth caller experience.

Special thanks to Simon, who pointed me in the right direction and helped unlock the proper approach to solving this cutoff bug. 🙏

Context

When building voice agents with ElevenLabs integrated with Twilio (either through a SIP trunk or via native Twilio integration), you often need the agent to transfer a call or end a call gracefully.

The problem: there’s a bug in ElevenLabs.

When the agent executes a call transfer, the call is cut off immediately, even before the agent finishes speaking.
The same happens when the agent ends a call—the cutoff is abrupt and unnatural.

This ruins the experience: the agent might say “Please hold while I transfer you…” but the line goes dead in the middle of the sentence.

Why this happens

Internally, ElevenLabs doesn’t handle the timing of call control well:

When transfer or end_call is triggered, the audio stream is cut right away.
There’s no native way to delay the cutoff until after the agent finishes speaking.

And this issue occurs in both cases:

SIP trunk integration with ElevenLabs
Native Twilio integration with ElevenLabs

The solution: implement `transfer_call` and `end_call` manually

⚠️ Important limitation:
This fix only works for numbers added through Twilio’s native integration (Programmable Voice).
If your numbers are connected via a SIP Trunk, Twilio does not allow updating or redirecting calls through the API. That’s why you’ll still get a 404 error when trying to apply this workaround on SIP Trunk calls.
(Reference: Twilio docs — Programmable Voice calls can be updated via API, SIP Trunk calls cannot.)

To fix this, you need to take control away from ElevenLabs and handle the call lifecycle yourself.

The approach:

Disable the native ElevenLabs tools for transfer and end call.
Create custom tools in your backend:

transfer_call
end_call

When ElevenLabs invokes one of these tools:

Immediately return 200 OK so ElevenLabs thinks everything worked and keeps the audio stream alive.
Enqueue a background job with a short delay (2–5 seconds).
That job uses the Twilio REST API to perform the real action:
Update the call with a new TwiML <Dial> for transfers.
Or mark the call as completed to hang up gracefully.

This way, the agent can finish the spoken message before the transfer or termination actually happens.

Example: `transfer_call` in Ruby on Rails

Job to trigger the transfer

class PhoneAi::TransferCallJob < ActiveJob::Base
  queue_as :default

  def perform(call_sid, destination)
    client = Twilio::REST::Client.new

    Rails.logger.info "📞 [TransferCallJob] call_sid=#{call_sid}, destination=#{destination}"

    result = client.calls(call_sid).update(
      url: Rails.application.routes.url_helpers.transfer_twiml_voice_calls_url(
        destination: destination,
        host: "my.host.com" # Make sure you have declared your route accordingly.
      ),
      method: "POST"
    )

    Rails.logger.info "✅ [TransferCallJob] Transfer success: SID=#{result.sid}, Status=#{result.status}"
  rescue Twilio::REST::RestError => e
    Rails.logger.error "❌ [TransferCallJob] Twilio error: #{e.message} (code=#{e.code})"
    raise
  end
end

TwiML endpoint for transfers

class Voice::CallsController < ApplicationController
  def transfer_twiml
    destination = params[:destination]

    response = Twilio::TwiML::VoiceResponse.new do |r|
      r.dial(number: destination)
    end

    render xml: response.to_s
  end
end

Example: `end_call` in Ruby on Rails

Job to end the call

class PhoneAi::EndCallJob < ActiveJob::Base
  queue_as :default

  def perform(call_sid)
    client = Twilio::REST::Client.new

    Rails.logger.info "📞 [EndCallJob] Ending call - call_sid=#{call_sid}"
    # You must specify in your system prompt to use this tool after saying goodbye; or you can use the job and delay strategy again so it does not get cutoff.
    result = client.calls(call_sid).update(status: "completed")

    Rails.logger.info "✅ [EndCallJob] Call ended: SID=#{result.sid}, Status=#{result.status}"
  rescue Twilio::REST::RestError => e
    Rails.logger.error "❌ [EndCallJob] Twilio error: #{e.message} (code=#{e.code})"
    raise
  end
end

How to use

ElevenLabs announces: “Thank you for calling, goodbye.”
It triggers end_call.
Your Rails backend responds immediately with 200 OK.
2 seconds later, the job executes update(status: "completed") and the call ends naturally.

Benefits of this approach

✔️ The agent finishes speaking before the line is cut.

✔️ You control the delay precisely (2s, 5s, etc).

✔️ Works for both transfers and call termination.

Conclusion

If you’re integrating ElevenLabs Voice AI with Twilio, you’ll likely encounter this bug: transfers and call endings are cut off too early.

The fix is to:

Implement your own tools (transfer_call and end_call).
Delegate the actual logic to Twilio using its REST API.
Insert a small delay so the agent can finish speaking before the action executes.

This gives you full control of the call flow and dramatically improves the caller’s experience.

How to Connect ElevenLabs with Twilio Using SIP Trunk (Not Webhooks)

David Muñoz — Mon, 22 Sep 2025 12:59:26 +0000

How to Connect ElevenLabs with Twilio Using SIP Trunk (Not Webhooks)

When integrating voice AI agents with telephony, most tutorials point you toward the native Twilio Webhooks integration. While this works, it’s not always the most flexible or reliable option.

In this article, I’ll show you how to connect ElevenLabs with Twilio using Elastic SIP Trunking, giving you full control over call routing without relying on webhook callbacks.

Why Use SIP Trunk Instead of Webhooks?

Lower latency: SIP trunking provides a more direct media path.
Stability: No dependency on webhook round trips.
Flexibility: Full control over authentication, routing, and encryption.
Compatibility: Works like a standard VoIP trunk, so you can reuse the same setup in other systems.

Step 1: Configure Twilio Elastic SIP Trunk

Go to your Twilio Console and navigate to Elastic SIP Trunking.

General Section

Click Create New SIP Trunk and give it a Friendly Name.
Keep all default options except:
- Call Transfer (SIP Refer): Set caller ID as transferee
- Enable PSTN Transfer → enabled
Save and continue to Termination.

Termination Section

Termination SIP URI
- Set your termination domain.
- Twilio will create it as:
```
 your-domain.pstn.twilio.com
```
IP Access Control List
- Click + to add a new list.
- Friendly Name: elevenlabs
- Add the IP range:
```
 34.49.132.122/32
 34.49.132.122-34.49.132.122
```
Credentials List
- Click + to create a username and password.
- Save these credentials — you’ll need them in ElevenLabs.
Adjust the rest according to your case.

Origination Section

Click + to add a new Origination URI.
Enter: sip:sip.rtc.elevenlabs.io:5060;transport=tcp
Priority: 10
Weight: 10
Enabled: checked
Optionally enable CNAM Lookup.

Numbers Section

Assign a phone number to your SIP trunk.
You can buy a new one or use an existing number.
Only numbers listed here will work under this SIP Trunk.

✅ Twilio setup is now complete. Next, let’s configure ElevenLabs.

Step 2: Configure ElevenLabs SIP Trunk

In the ElevenLabs dashboard, go to Phone Numbers → Import Number → From SIP Trunk.

Basic Information

Label: give it a friendly name.
Phone number: choose the same number you added in Twilio’s Numbers section.

Inbound Configuration

Media Encryption: Allowed
SIP Trunk username: the username you created in Twilio
SIP Trunk password: the password you created in Twilio

Outbound Configuration

Address: your Twilio termination domain, e.g.: your-domain.pstn.twilio.com
Transport Type: TLS
Media Encryption: Allowed
SIP Trunk username: same as Twilio
SIP Trunk password: same as Twilio

Step 3: Assign an Agent

Once the number is imported, open its configuration in ElevenLabs.
Select the AI agent that should handle calls on this number.

And that’s it! Your ElevenLabs agent is now connected to Twilio via SIP trunking. 🎉

Testing the Integration

Place a call to your Twilio number.
Verify that the call is routed to ElevenLabs and handled by the assigned agent.
Check audio quality and logs to ensure SIP authentication is working.

Conclusion

By connecting ElevenLabs with Twilio using SIP trunking, you gain a more reliable, flexible, and scalable integration compared to the webhook approach. This method allows you to:

Securely authenticate calls with SIP credentials.
Enable encrypted media (TLS + SRTP).
Assign numbers to specific AI agents with full control.

If you’re building production-ready AI voice agents, this SIP Trunk approach is the way to go. 🚀

💬 Have questions or ran into issues? Drop a comment below or reach out — happy to help!

Setting up Ruby on Rails with RVM, Puma, Mina, Nginx, Sidekiq and Redis on Amazon Linux 2

David Muñoz — Tue, 29 Oct 2024 19:02:52 +0000

After using for several years this same stack on Ubuntu, our AWS Expert recommended us to move to Amazon Linux 2 in order to take advantage of optimized hardware, pricing and other benefits of using their OS.

The stack includes:

Ruby (Installed using RVM, but you can use any other version manager, or compile yourself ruby)
Nginx (As web server + reverse proxy to Puma server)
Puma (As rails app server)
NodeJs + Yarn (If your application needs to compile assets)
Sidekiq (For background jobs processing)+ Redis (As persistence engine for Sidekiq). Since you are in AWS ecosystem you could also use Elasticache instead of local Redis, just parameterize correctly your Sidekiq if you want to do so.
Mina (For deployments, but you could use Capistrano, or git clone/pull the project manually)

I made this same guide for Ubuntu (Thanks to Serhan Balcı for stealing my article. Please increase awareness of this guide by stealing it again and posting it as yours, lol). See:
Setting up Rails app in Ubuntu machine (RVM + Sidekiq + Nginx + Puma + Capistrano)

Upgrading your system and installing dependencies

The following updates the system, installs git, cmake, nginx and postgres client. Note that if you do not use postgres as database client of your app, you would have to use proper client libraries, for example mysql.

Before copy and paste the following commands please be aware that it installs postgres libraries. If you don’t use postgres omit them. If you don’t want to accept the libraries installing right away remove the -y argument.

sudo yum update -y
sudo yum install curl git gcc make -y
sudo amazon-linux-extras install nginx1 postgresql11 -y
sudo yum install postgresql-devel postgresql-libs -y

In addition you can customize your hostname with, replace railsapp with how you want your host to be labeled:

sudo hostnamectl set-hostname railsapp

Installing Ruby

My personal choice is RVM, but you could also use other options or compile ruby from source yourself.

Import RVM gpg key (You should use the key from rvm.io site, not the one posted anywhere on internet for security reasons, be aware!):

gpg — keyserver keyserver.ubuntu.com — recv-key 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB

After imported download and run the RVM installation script with:

curl -sSL [https://get.rvm.io](https://get.rvm.io) | bash

Then source it, note how my default user is ec2-user, if it is different change it to your user name. (Or exit and login back with SSH):

source /home/ec2-user/.rvm/scripts/rvm

Now install your desired ruby (In my case I am using latest 2.x version, which is 2.7, but you can install the one that suits your app):

rvm install 2.7.0
rvm use 2.7.0 — default

Now you can test it with ruby -v command:

Setting up Nginx

Basically you got to place your app configuration inside a file that should be imported in the nginx conf. In order to do that my suggestion would be to create a folder, then create a file that contains the app configuration and then referencing it in nginx.conf file:

Create the folder:

sudo mkdir /etc/nginx/sites-enabled

Create the file:

sudo nano /etc/nginx/sites-enabled/app.conf

Now this command initialized a file in the previous created folder named as app.conf, but it will only be saved once we fill in with contents and save it using nano, you can use your editor of preference. Place the following configuration and be sure to tweak it to your needs:

Now lets include this configuration file in nginx.conf file:

sudo nano /etc/nginx/nginx.conf

Inside the http block, include the following line:

include /etc/nginx/sites-enabled/*.conf;

So it looks like this:

In addition of our purposes this will tell nginx to include all configuration files inside the sites-enabled folder, so if you got more apps/pages you could include another app.conf file there and it will be loaded by nginx. Also you could add sites-available folder and symlink your configuration files in sites-enabled but thats out of the scope of this guide, just a recommendation.

Finally, and pay attention here, the nginx got to have access to the application’s path, so you either setup proper permissions OR run nginx as your ruby user, in this case ec2-user. For educational purposes lets just scroll up to the first line of the nginx.conf file and set and replace the user to *ec2-user *(or the user you are using).

user ec2-user;

Save and exit (With Ctrl + X if using nano).

Enable your nginx service:

sudo systemctl enable nginx

Installing your Rails app

Now, here is my suggested folder structure. It is friendly with mina and capistrano, also if you want to implement different stages like staging or production it would be work too, but you are free to use any.

Note that if you change it you got to modify your app.conf file for nginx. Remember to reload nginx each time you modify those configuration files.

The folders structure is:

production
-> railsapp
--> current
--> releases
--> shared

Inside the current directory is where our Rails application would be. Lets create the structure and clone our project

cd
mkdir production
cd production
mkdir railsapp
cd railsapp
git clone xxx
mv xxx current

See how I renamed the folder project with just current. If you cd current **and print your path it would show like this:**

Now lets install bundler and then install all our gems from our Gemfile:

gem install bundler
gem update --system
gem update bundler
bundle install --without development test

You might encounter errors in this process if your Gemfile contains gems that needs dependencies that we have not installed. So you got to closely check at errors in this step and look what dependencies are unmet. For example in our case we assumed that we were working with Postgres, so we installed in the first section of this guide the Postgres dev libraries, if we would have not done that then we would get an error in this step because our Gemfile contains the pg gem. If you are using Mysql or other driver, you have to stop here and install the proper dependencies.

But if your Gems list installed successfully then let’s continue by setting up Puma service as systemd service so we see our App in action.

Note: If you are using dotenv, or you need to add further environment variables this is when. Create your .env.production file and fill it in now.

Setting up Puma

We are setting up puma to run binding to a Unix socket, not TCP socket, here is a good explanation on why it is a good idea.

Assuming you are using Puma and it was installed because it was located in your Gemfile, then you should have it ready to use. You can cd into your app folder and run puma command and it will try to boot your application in development mode. But let’s install it as a systemd service.

sudo nano /etc/systemd/system/puma.service

This will initialize a file in the system directory, which should include your puma configuration. Replace the paths and the user to your needs.

Save and exit (Ctrl + X if using Nano).

Now enable it with:

sudo systemctl enable puma

Before we can start our Puma service we need to make sure that our application contains proper configuration. See how the puma.service file refers to config/puma/production.rb file. You should modify that file accordingly, also note that this production file could be named different depending on the stage you are using, for example staging.rb if that is the case.

The previous gist is quiet generic, in terms that the app_dir variable was set to a value were it contains the path of 3 levels up of the production.rb file, and that is because the app root is located in:

/home/ec2-user/production/current/

But our puma production.rb configuration file is located in:

/home/ec2-user/production/current/config/puma/production.rb

If this is not the case your place your Rails app root folder in app_dir. I just tried to make it generic.

Also note that we send a true to the daemonize method. Current puma version needs the daemonize option to be in that file and not in the service configuration. Depending on your puma version (Older versions needed this, as in my previous Ubuntu guide) you would have to remove that from the puma configuration file and just add the argument -d in the puma.systemd file at the end of the ExecStart command. As of writing of this guide latest Puma is 5.6.4 (Birdie’s version)

Finally check that we are setting our puma logs to be written in log/* directory, we are needing to read those files later if we find any troubles.

Make sure your project contains the puma configuration folder and now start the puma service:

sudo service puma start

This should start your puma service. If it doesn’t check the following:

Your app has connection to your database, try to run the rails console in your project directory and execute any SQL query. Make sure you placed all your environment variables, if needed.
Your puma configuration contains correct paths.
The version of your ruby matches the ruby you placed in your puma.system file, note that for this guide we are using 2.7.0
Check the puma.stderr.log and puma.stdout.log for any outputs that would prevent the app from starting (Like a sytanx error in your application, if this is the case the puma running in Development mode won’t catch any syntax error because it does not do a full scan of the source code, but in production the boot process does it)
Check the output of jornalctl -u puma -f -n 100
As a final check just go to your app folder, run puma -e productionand let it start. Then in a different ssh session run curl localhost and check the output of first ssh session.

Now you should have puma running your Rails app. Stop it and let’s setup deployment with Mina.

sudo service puma stop

Setting up Redis (Optionally needed for Sidekiq)

First you got to install Redis, fortunately our friend jpickwell created a super simple script to install on AL2, just use it and it will do all, no questions, lol.

Remember we are using local Redis, if you are in AWS ecosystem you might want to use Elasticache, if so you don’t have to install Redis, you just have to configure Sidekiq to use Redis on from Elasticache service, you would then skip this section of the guide and go to setup sidekiq. If that is not the case then keep going and by default Sidekiq will try to connect to local redis using REDIS_URL=redis://localhost:6379 .

wget -O redis_install.sh [https://gist.githubusercontent.com/jpickwell/e6857da4ba17c83ef09729c5d448f6bb/raw/67783f35b666afb38e82120781f7ceb75ef1f1f9/install-redis.sh](https://gist.githubusercontent.com/jpickwell/e6857da4ba17c83ef09729c5d448f6bb/raw/67783f35b666afb38e82120781f7ceb75ef1f1f9/install-redis.sh)

(Or you could install it yourself, I got burnt trying to find out how to do a clean installation, leave in the comments if you find an easy way to do it using yum or whatever)

Run the installation script:

sudo sh redis_install.sh

Make sure it is running by typing redis-cli and the PING command:

Now Redis is installed, we can now setup Sidekiq.

Setting up Sidekiq

Assuming you got access to an Elasticache Redis instance OR you got Redis listening on localhost you should now setup the Sidekiq systemd configuration file.

sudo nano /etc/systemd/system/sidekiq.service

Now modify to your needs the following sidekiq configuration script

Modify the user and the WorkingDirectory path. Make sure you have a config/sidekiq.yml file that contains your sidekiq configuration, for example it could be simple as:

:concurrency: 5
:queues:
- default
- critical

Now enable it:

sudo systemctl enable sidekiq

And start it:

sudo service sidekiq start

If it does not start then same as Puma troubleshooting you should check why would it be not starting, most likely a miss configuration in the boot time, like a missing environment variable or lack of database connection. If none of the above works try to run Sidekiq manually and let it output any errors by just stepping in your rails app root and running sidekiq .

Setting up NodeJS and Yarn (If your application needs assets precompile)

If your application needs to compile your assets then you would have to install NodeJS and Yarn. If your Rails app is api-only you can skip this step and remove the precompilation task from deploy.rb file.

First install the Node repo (I am placing here the URL but you should go into nodejs site and pick the repo URL from there)

curl -sL https://rpm.nodesource.com/setup_16.x | sudo -E bash -

Now install NodeJS:

sudo yum install nodejs -y

Confirm with node -v

Now install Yarn repo:

curl -sL https://dl.yarnpkg.com/rpm/yarn.repo | sudo tee /etc/yum.repos.d/yarn.repo

and install Yarn:

sudo yum install yarn -y

We will see how it works in the deployment script. If you omit previous steps Mina (or any) won’t be able to run rails assets:precompile task.

Deployment with Mina

First lets erase the project folder and let’s prepare the folder structure that Mina needs in order to make deployments.

cd
rm -rf production/railsapp

Now logout of your remote machine and go back to local. Setup the following deployment script. Place it in config/deploy.rb.

You would have to edit the following variables:

application_name
domain: Put your remote ip or Url
deploy_to: Make sure it matches your app path
repository: The git repository (Make sure you have ssh access)
branch
user: The user which you use to connect with ssh
forward_agent: Leave it to true, but make sure your id_rsa.pub is included in remote’s machine ssh/authorized_keys file.

After that is ready just run the mina setup command and it will create mina’s folder structure for your project using the parameters you setup before. Read more info on mina setup on their Getting started guide.

mina setup

This will ssh in to your remote machine and create the proper folder structure, now in case you are using dotenv you have to SSH back in to your remote machine and place the proper content of .env.production file in production/railsapp/shared/.env.production . This is because on deployment mina creates a symlink of this file in the current version’s folder of the project, so you don’t have to setup that file each time or even worst, upload your sensitive data in a repository. If you need mina to symlink more files or folders modify your shared_files variable in the deploy.rb script.

Note how in the deploy.rb file we have a command to run assets precompilation, if your Rails app is api-only you can remove that line.

Now you are ready, just run deploy and it will show you what troubles it encounters. Read them closely as almost all the times the problem is something quite obvious but one tend not to read the complete error description.

mina deploy

Bonus: Setup SSL with Lets encrypt and Certbot

If you need to setup SSL for your project I highly recommend to use Lets Encrypt and Certbot to basically do all the work for you. (Love those guys, when I go billionaire I will send some churros, promise).

Install EPEL packages:

sudo amazon-linux-extras install epel -y

Install certbot for nginx:

sudo yum install -y certbot python2-certbot-nginx

Go back to your /etc/nginx/sites-enabled/app.conf file and replace your server directive to use your secured URL:

server_name example.com www.example.com;

Save it, reload and check nginx configuration with:

sudo service nginx reload
nginx -t

If all went good you are ready to run Certbot:

sudo certbot --nginx -d example.com -d [www.example.com](http://www.example.com)

Follow the instructions and you are ready to go!

Conclusion

We have setup a Rails app with all the basic dependencies on Amazon Linux 2 machine, ready to run for a production environment. All the steps described are just the collection of steps that I have gathered through the years; some of them could seem hackish but I encourage you to improve this process by leaving in the comments any ideas on how to make this smoother.

Multiple deployments and High Availability with Mina and Ruby on Rails

David Muñoz — Tue, 29 Oct 2024 18:57:52 +0000

Recently we realized that we needed a High Availability model on our infrastructure with some of our Monolithic and Micro services projects on Ruby on Rails.

That means we needed, in terms of code delivery, to make same project version deployment into multiple machines at once.

However this model is generic to any client-server / monolithic / micro services approach and to any languages and frameworks. In my project I use Mina (Formerly using Capistrano), so that means that on each deployment the script makes a SSH-in to the remote machine and performs the deployment process: Git clone, Git pull, rake db:migrate assets:precompile, puma:restart, etc… Before using Capistrano I was doing all this manually #sigh.

Fortunately Mina allowed to do all this just by setting up the deployment script through the deploy.rb file, now the next challenge would be on how to do deployment on many remote machines using the same deployment script (without modifying it each time or running multiple commands).

Mina or Capistrano?

Why do I use Mina instead of Capistrano? I won’t write it here since Infinum guys already did a great explanation and comparison:

But even so, this solution would fit Capistrano deployment script too. See also:
Setting up Rails app in Ubuntu machine (RVM + Sidekiq + Nginx + Puma + Capistrano)

There is already a Mina multi deploy gem

The guys at Codica managed to solve this problem with mina-multideploy gem, but quickly I found a problem that wouldn’t let me continue use it, so instead of creating the issue, look around for a solution and doing a PR… 😅 I did a little of scripting myself using Mina tasks and achieved to do inline (one at a time, one after the other) deployments using just a few ruby lines.

Problem with mina-multideploy is that they use a parallelism model and if one fails nothing happens; not even a warning or an error output, that could lead to unwanted results if you are using a HA infrastructure model, since different app versions would be running over the same load balancer and that would be 🤯 to troubleshoot (Trust me, been there).

You can try yourself by creating a deploy.lock file (Using mina, or manually creating it in the remote’s server path) on one of the remote machines and then running the bundle exec rails multideploy:start to do deployment on all the target machines; you will see the deployment success, however we had a remote machine deploy-locked 👎

The solution

This solution is environment friendly, in our case we will use production as our environment but we can declare staging too.

Step 1

Let’s assume that you have your deploy.rb with generic settings, mine are:

Step 2

Now simply declare a hash of your desired environments with useful info inside of each one; if you wish you could just leave the urls array, in my case each of the stages need to restart different amount of Sidekiq services and should compile assets only in production:

Step 3

Now let’s declare a task named as each of our environments. If you have more options for each of your stage this is the step where to add variables that will be considered later in our deploy task:

Step 4

Now we should simply write our deploy task. Note that we only invoke the assets_precomiple task if the assets_precompile variable is set to true. Same with Sidekiq services were i got them listed in my remote machines as Sidekiq1, Sidekiq2, … If you don’t have any custom settings per stage just remove those specific command lines.

And finally we just create our multideploy task:

Now we can just run mina production multideploy and it will:

Loop through the urls array that we set in the first step
For each URL in the production stage it will set the domain and the rails_env .
Invoke the deploy task that will also execute additional invocations per our options that we declared in our stage setting step.

Bonus

Now if we want to connect to our console over a specific stage we can invoke the console by overwritting the console task:

It will grab the first value of the urls array and will invoke the old reliable console task. Since we are using a HA strategy all our remote machines should be the same (supposedly). We can now call mina production console .

Our final deployment script would look like this:

Next steps

Since we are looping through an array of remote machines IPs and doing each deployment inline what happens if 1 of them fails? The answer is that the deployment will raise an exception and you will have a nice Error output from our deployment script, now we need to implement a way to safely rollback all of our remote machines to a stable project’ s version. Please leave in the comments any ideas on how to achieve this.

High Availability with AWS

Now that we have managed our multiple deployment strategy using Mina (But also reproducible on Capistrano) we should setup a load balancer, in my case with AWS is just a few clicks away; I will not go deep into this since there is a lot out there on how to do it, also if you are not in AWS ecosystem you could setup your load balancer using any other service, like Nginx which allows you to make a simple load balancer with a few lines of code.

Step 1

Create a target group:

Step 2

Create a load balancer

Select the target group we created on step 1:

Click on create and make sure your rules are in place. Once provisioned you should be ready to test your load balancer URL.

Step 3

Make your DNS point your app URL to the load balancer address.

Thats pretty much it!

Final notes

High availability goes beyond of having multiple machines being balanced over all of the requests, but this is a first step that you should consider once you need to guarantee uptime, resources usage optimization, failover strategies and so others on your project.

Please leave in the comments any ideas, questions or ways to improve this topic.

Cómo desplegar una app de Ruby on Rails en Ubuntu 22

David Muñoz — Tue, 29 Oct 2024 18:49:02 +0000

TLDR;

Desplegar una aplicación en Ruby on Rails en producción es un proceso que cada vez que se hace tiene un problema diferente. De esto depende las gemas, las dependencias y el sistema operativo que se use. Veremos como se despliega en Ubuntu 22 siendo la base más sencilla sobre la que se puede operar, con gemas estándar y con un código fuente de ejemplo que incluyo.

Para este tutorial utilizaremos DigitalOcean como proveedor de servicios en la nube.

Usando este link obtienes un bono de $200 en DigitalOcean para que puedas hacer este tutorial y usarlo en futuros despliegues.

Nota: Este tutorial también está en Youtube, donde explico en formato de video el paso a paso y doy comentarios acerca de cada paso.

EstoyProgramando es un canal en Youtube que enseña cómo incursionar en el mundo del desarrollo de software.

Cualquier persona de cualquier carrera puede cambiar su profesión a programador debido a las múltiples facilidades que se encuentran disponibles, también aprovechando el mercado laboral que se encuentra en auge.

Suscríbete a mi canal para más contenido de cómo iniciar en el mundo de la programación, además de encontrar contenido específico de programación en Ruby.

Paso 1.

Crea un servidor Ubuntu versión 22.04 (LTS). Recomiendo mínimo 1GB de RAM.

En la sección de método de autenticación puedes escoger Password por simplicidad, o puedes configurar tus llaves de acceso.

Al final hacer click en Crear. Cuando se termine de crear ya podemos acceder por protocolo SSH al Droplet (es decir, al server)

Abrimos la Terminal (o la aplicación de línea de comandos según el sistema operativo que se tenga) e ingresamos el comando de ssh con el usuario root y la ip del Droplet.

ssh root@1.2.3.4

Ahora configuramos el usuario con el que vamos a operar, todos estos comandos deben ingresarse en la aplicación de Terminal con la sesión de SSH abierta en nuestro server remoto.

En los siguientes comandos voy a crear mi usuario david, si tu usuario se llama diferente debes ajustar todos los comandos con el nombre del usuario adecuado.

Crear el usuario:

sudo adduser david

Agregar el usuario al grupo de sudoers:

sudo usermod -aG sudo david

Cambiamos desde el usuario root al usuario david:

su david
# Pide la contraseña

Cambiamos el nombre del host (Cambiar server por el nombre que quieras asignar al servidor):

sudo hostnamectl set-hostname server

Para ver los cambios en el nombre del servidor podemos salir con exit y reingresar con su david .

Paso 2.

Con la sesión abierta y el usuario designado logueado vamos a actualizar el sistema e instalar las librerías necesarias:

sudo apt-get update
sudo apt-get install software-properties-common
sudo apt-get install libssl-dev

Ahora podemos instalar RVM (Aunque se puede usar cualquier otro manejador de versiones de Ruby)

\curl -sSL https://get.rvm.io | bash -s stable

Aquí debe salir un error, el cual pide que agregues la clave del autor, por razones de seguridad no coloco ese comando aquí.. pero puedes copiarlo y pegarlo. Una vez lo hagas corre de nuevo el comando anterior para instalar RVM.

Ahora vamos a cargar el RVM con el comando:

source /home/david/.rvm/scripts/rvm

Así, el comando rvm ya estará disponible.

Luego instalamos openssl:

rvm pkg install openssl

Y ahora si instalamos Ruby indicándole el directorio de OpenSSL:

rvm install 3.0.4 --with-openssl-dir=$HOME/.rvm/usr

(En mi caso instalé la versión 3.0.4, pero según cuando estés haciendo este tutorial puede haber otra versión más reciente)

Este comando debe demorarse varios minutos…

Mientras esperas te recomiendo algunos de mis videos más populares:

📚 Tips para conseguir trabajo como programador

📚 Debo estudiar ingeniería de sistemas?

📚 Estudiar programación en el 2023

📚 Cómo aprendí a programar

📚 Por qué aprender Ruby?

📚 Los programadores deben saber inglés

📚 Curso de fundamentos de programación

Ahora puedes indicarle al sistema operativo que use por defecto la versión de Ruby que acabamos de instalar, con el comando:

rvm use 3.0.4 --default

Si te da un error debes modificar el archivo ~/.bashrc:

# nano ~/.bashrc
# Puedes incluirlo al final del archivo:
source ~/.rvm/scripts/rvm

Luego de salir y regresar a la sesión del usuario ya el comando rvm use debería funcionar correctamente.

Paso 3

Debes clonar el código del proyecto en cualquier parte de la carpeta de tu usuario. Por ejemplo, podemos usar este proyecto de ejemplo el cual es un pequeño sistema de información en Ruby on Rails 7 o puedes usar tu propio proyecto. Si usas tu propio proyecto debes considerar las dependencias específicas, por ejemplo si necesitas librerías adicionales para que las gemas de tu proyecto funcione.

git clone https://github.com/damuz91/mi-bodega-rails

luego accedemos a la carpeta recién creada con el comando cd y corremos el comando bundle install . Aquí podrán salir errores si acaso el comando bundle no logró instalar las gemas listadas en el Gemfile, esto normalmente es porque harán falta algunas librerías para compilar las gemas necesarias.

En este video hacemos el sistema que usamos de ejemplo en este tutorial.

Los siguientes pasos corresponden a configuración específica del proyecto de ejemplo aunque podrían ser usados en tu caso también:

Borramos el credentials.yml.enc existente: rm config/credentials.yml.enc
Generamos un nuevo archivo de credenciales: Editor="nano --wait" bin/rails credentials:edit
Creamos y migramos la base de datos: rails db:create db:migrate db:seed RAILS_ENV=production

Los pasos 1 y 2 pueden no aplicar en tu caso si acaso el proyecto tiene credenciales encriptadas en el archivo y si cuentas o no con la clave correcta en el archivo master.key .

Paso 4

Vamos a instalar Nginx para administrar las peticiones web entrantes:

sudo apt-get install nginx

Creamos el archivo donde colocaremos la configuración de nginx:

sudo nano /etc/nginx/sites-enabled/app.conf

Colocamos el siguiente script con cuidado de modificar la ruta adecuada según donde esté ubicada la carpeta de tu proyecto:

upstream app {
  server unix:///home/david/mi-bodega-rails/puma.sock fail_timeout=0;
}

server {
  server_name _;
  root /home/david/mi-bodega-rails/public;

  location ^~ /assets/ {
    gzip_static on;
    expires max;
    add_header Cache-Control public;
  }

  location / {
    proxy_pass http://app;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    # proxy_set_header X-Forwarded-Host 'www.railsapp.com';
    proxy_set_header X-Forwarded-Proto $scheme;
  }

  location ~ ^/(500|404|422).html {
    root /home/david/mi-bodega-rails/public;
  }

  error_page 500 502 503 504 /500.html;
  error_page 404 /404.html;
  error_page 422 /422.html;

  client_max_body_size 4G;
  keepalive_timeout 10;
}

Borramos la configuración por defecto anterior:

sudo rm /etc/nginx/sites-enabled/default

Corremos el servicio de nginx como nuestro usuario (Otra alternativa es dar permisos al usuario www-data de lectura y escritura a la carpeta del proyecto):

sudo nano /etc/nginx/nginx.conf
# Modificar la primera linea:
user david # En lugar de www-data. Coloca el nombre de tu usuario

Reiniciamos nginx:

sudo service nginx restart

Ahora creamos el script para que el servidor de App PUMA corra en el Systemd:

sudo nano /etc/systemd/system/puma.service

Y colocamos la siguiente configuración (Recuerda ajustarlo a tu usuario y directorio del proyecto):

[Unit]
Description=Puma HTTP Server
After=network.target

[Service]
Type=simple
User=david
WorkingDirectory=/home/david/mi-bodega-rails
Environment=RAILS_ENV=production
ExecStart=/home/david/.rvm/gems/ruby-3.0.4/wrappers/bundle exec puma -C /home/david/mi-bodega-rails/config/puma/production.rb
Restart=always
KillMode=process

[Install]
WantedBy=multi-user.target

Luego reiniciamos el servicio y activamos la nueva configuración:

sudo systemctl daemon-reload
sudo systemctl enable puma

Precompilamos los assets de nuestro proyecto:

cd /ruta/al/proyecto
bundle exec rails assets:precompile RAILS_ENV=production

E iniciamos (o reiniciamos) el servidor de Puma:

sudo service puma restart

Y debería cargar la aplicación:

Cualquier error que surja se puede consultar en:

log/production.log
log/pumastdout.log
log/pumastderr.log
sudo journalctl -u puma -f -n 100

Este mismo tutorial en versiónAmazon Linux 2 lo encuentras en mi perfil.

Cualquier pregunta o comentario es bienvenido!

DEV Community: David Muñoz

Fixing the ElevenLabs Call Transfer Bug with Twilio

A note on frustration

Context

Why this happens

The solution: implement transfer_call and end_call manually

Example: transfer_call in Ruby on Rails

Job to trigger the transfer

TwiML endpoint for transfers

Example: end_call in Ruby on Rails

Job to end the call

How to use

Benefits of this approach

Conclusion

How to Connect ElevenLabs with Twilio Using SIP Trunk (Not Webhooks)

How to Connect ElevenLabs with Twilio Using SIP Trunk (Not Webhooks)

Why Use SIP Trunk Instead of Webhooks?

Step 1: Configure Twilio Elastic SIP Trunk

General Section

Termination Section

Origination Section

Numbers Section

Step 2: Configure ElevenLabs SIP Trunk

Basic Information

Inbound Configuration

Outbound Configuration

Step 3: Assign an Agent

Testing the Integration

Conclusion

Setting up Ruby on Rails with RVM, Puma, Mina, Nginx, Sidekiq and Redis on Amazon Linux 2

Upgrading your system and installing dependencies

Installing Ruby

Setting up Nginx

Installing your Rails app

Setting up Puma

Setting up Redis (Optionally needed for Sidekiq)

Setting up Sidekiq

Setting up NodeJS and Yarn (If your application needs assets precompile)

Deployment with Mina

Bonus: Setup SSL with Lets encrypt and Certbot

Conclusion

Multiple deployments and High Availability with Mina and Ruby on Rails

Mina or Capistrano?

There is already a Mina multi deploy gem

The solution

Step 1

Step 2

Step 3

Step 4

Bonus

Next steps

High Availability with AWS

Step 1

Step 2

Step 3

Final notes

Cómo desplegar una app de Ruby on Rails en Ubuntu 22

TLDR;

Paso 1.

Paso 2.

Paso 3

Paso 4

The solution: implement `transfer_call` and `end_call` manually

Example: `transfer_call` in Ruby on Rails

Example: `end_call` in Ruby on Rails