Logo worker@2x

High-Scale Async Processing

An easy-to-use scalable async processing task queue that gives cloud developers a simple way to offload intensive front-end tasks, run scheduled jobs, and process tasks in the background and at scale.
Worker diagram


Announcing Dedicated & High Mem/CPU Instances


Custom worker environments for maximum reliability, higher task priority and more processing power


Ready

Ready To Use

Upload workers and run them seamlessly in the cloud. Get running in minutes and add instant background/async processing and scheduling.

Code

Runs Your Code

Write workers as if to run in your app but then simply upload and run them in IronWorker. Works with Ruby, Python, PHP, Java, .NET, Node, Go and more.

Highscale

High-Scale Processing

Run many tasks at once – tens, hundreds, thousands. No need to stand up servers or manage queues. Scales to handle whatever workload you send it.

Secure

Secure

Uses SSL connections and runs each task in a Linux-protected LXC sandbox. Uses OAuth2 to provide simplicity, flexibility, scalability, and security.

Reliable

Reliable

We offer high memory/CPU instances or dedicated workers to guarantee maximum reliability for your critical task processing needs.

Containers

Custom Containers

Define custom runtime environments and write workers for specific language versions. Use the latest versions or lock-down your environment.

Available

Flexible Scheduling

Schedule jobs to run in the future using flexible options. Run once, a set number of times, on a recurring schedule, and many options in between.

Monitoring

Monitoring

Check the status of tasks and view logs. View graphs of task usage, get alerts and notifications, and stay on top of queued, running, and completed tasks.

Maintenance

No Maintenance

Easy replacement for Celery, Resque, Delayed Job, and other worker systems. Switch from self-managed to a scalable service with no setup / no maintenance.



How It Works



Offload your tasks to the parallel-processing power of the elastic cloud. Write your code, then queue tasks against it. No servers to manage, no scaling to worry about.


Write
Package
Upload
Schedule
Inspect

Write Your Worker

IronWorker's environment is just a Linux sandbox that your task is executed in. Anything you write that runs on your machine, if packaged correctly, should be able to be run in IronWorker.

Create Your Code Package

Package all your code and its dependencies together and upload it to IronWorker so your code can run entirely on IronWorker's servers.

Upload Your Code Package

Once you've defined your worker and its dependencies with a .worker file, you can upload it using the command line tool for IronWorker.

Schedule Your Task

You can either queue your tasks to run in parallel, or schedule them to run at specific times from the command line or directly from your application.

Inspect Your Worker

To aid in debugging, everything that is printed to STDOUT in a worker is logged to your dashboard or you can hook up an external service to collect your logs.




We Speak Your Language

We provide client libraries for just about every language and framework to make working with IronWorker easy and familiar.

Learn More in the Dev Center ->





Ruby
Php
Java
Go
Dotnet
Node
Python

	# Create zip file containing all of the files your project needs.

	# Upload Worker
	curl -H "Authorization: OAuth TOKEN" -X POST \
	-F "file=@worker.zip;type=application/zip" \
	-F 'data={"file_name": "hello_worker.rb","name": "hello","runtime": "ruby"}' \
	"https://worker-aws-us-east-1.iron.io/2/projects/PROJECT_ID/codes"

	# Queue task with payload {"foo": "bar"}
	curl -H "Authorization: OAuth TOKEN" -H "Content-Type: application/json" \
	-d '{"tasks": [{"code_name": "hello", "payload": "{\"foo\": \"bar\"}"}]}' \
	"https://worker-aws-us-east-1.iron.io/2/projects/PROJECT_ID/tasks"

	# Run task once per hour
	curl -H "Authorization: OAuth TOKEN" -H "Content-Type: application/json" \
	-d '{"schedules":[{"payload":"{}","name":"hello","code_name":"hello","run_every": 3600}]}' \
	"https://worker-aws-us-east-1.iron.io/2/projects/PROJECT_ID/schedules"


	# Worker code can be anything you want.
	puts "Payload: #{params}"
	puts "Simulating hard work for 5 seconds..."
	5.times do |i|
	puts "Sleep #{i}..."
	sleep 1
	end
	puts "Completed at #{Time.now}"

	# Create hello.worker file

	# define the runtime language
	runtime 'ruby'

	# exec is the file that will be executed:
	exec 'hello_worker.rb'

	# Upload Worker
	$ iron_worker upload hello

	# Queue Workers
	require "iron_worker_ng"
	client = IronWorkerNG::Client.new
	# launch 100 tasks in parallel
	100.times do
	client.tasks.create("hello", foo: "bar")
	end

	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2


	# Create Workers
	print "Hello from IronWorker!\n"

	#Create hello.worker file

	# define the runtime language
	runtime 'python'

	# exec is the file that will be executed:
	exec 'hello_worker.py'

	# Upload Worker
	$ iron_worker upload hello

	# Queue Workers
	from iron_worker import *
 
	worker = IronWorker(token="IRON_IO_TOKEN", project_id="IRON_IO_PROJECT_ID")
	response = worker.postTask(name="hello", payload={"foo": "bar"})

	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2


	// Worker code can be anything you want.
	echo "payload:";
	print_r(getPayload());
	echo "Simulating hard work for 5 seconds...";
	for ($i = 1; $i <= 5; $i++) {
		echo "Sleep $i\n";
		sleep(1);
	}
	echo "Completed at ".date('r');

	#Create hello.worker file

	# define the runtime language
	runtime 'php'

	# exec is the file that will be executed:
	exec 'hello_worker.php'

	# Upload Worker
	$ iron_worker upload hello

	require("phar://iron_worker.phar");
	 
	$worker = new IronWorker();
	$worker->postTask("hello", array('foo' => bar));

	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2


	# Create Workers
	console.log("Hello from IronWorker!")

	#Create hello.worker file

	# define the runtime language
	runtime 'node'

	# exec is the file that will be executed:
	exec 'hello_worker.js'

	# Upload Worker
	$ iron_worker upload hello

	# Queue Workers
	var ironWorker = require('iron_worker');
 
	var client = new ironWorker.Client();
	 
	client.tasksCreate('hello', {foo: 'bar'}, {}, function(error, body) {
		console.log(body);
	});

	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2


	# Create Workers
	public class HelloWorker {
		public static void main(String[] args) {
			System.out.println("Hello from IronWorker");
		}
	}

	# define the runtime language
	runtime 'java'

	# exec is the file that will be executed:
	exec 'hello_worker.jar'

	# Upload Worker
	$ iron_worker upload hello

	# Queue Workers
	import io.iron.ironworker.client.Client;
	import io.iron.ironworker.client.entities.TaskEntity;
	import io.iron.ironworker.client.builders.Params;
	import io.iron.ironworker.client.builders.TaskOptions;
	 
	Client client = new Client("IRON_IO_TOKEN", "IRON_IO_PROJECT_ID");
	 
	TaskEntity t = client.createTask("hello", Params.create("foo", "bar"));

	# Schedule Workers
	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2


	# Create Workers
	using System;
	using System.IO;
	 
	public class HelloWorld
	{
		static public void Main(string[] args)
		{
			Console.WriteLine( "Starting HelloWorker at " + string.Format("{0:HH:mm:ss tt}", DateTime.Now));
			int ind = Array.IndexOf(args, "-payload");
		}
	}

	# define the runtime language
	runtime 'mono'

	# exec is the file that will be executed:
	exec 'hello_worker.exe'

	# Upload Worker
	$ iron_worker upload hello

	# Queuing from code not supported yet but you can queue from the command line
	$ iron_worker queue hello -p '{"foo":"bar"}'

	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2


	# Create Workers
	package main
 
	import "fmt"
	 
	func main() {
		fmt.Println("Hello from IronWorker!\n")
	}

	# define the runtime language
	runtime 'go'

	# exec is the file that will be executed:
	exec 'hello_worker.go'

	# Upload Worker
	$ iron_worker upload hello

	# Queuing from code not supported yet but you can queue from the command line
	$ iron_worker queue hello -p '{"foo":"bar"}'

	# Run task once per hour at high priority
	$ iron_worker schedule hello --start-at "2013-01-01T00:00:00-04:00" \
	--run-every 3600 --priority 2

How IronWorker Compares With Other Task Queues

Logo worker white@2x Heroku Workers Celery Resque
High Performance Task Queue
Workers as a Service
High Availability
Massively Scalable
Elastic
Retries
Max Concurrency
Redundant/Failover
Backed Up
Webhook Support
Shareable
Dashboard
Reporting & Analytics
Email Reports
CORS Support
Custom Language Containers
Authentication OAuth2 None None None
Languages Python, Ruby, PHP, .NET, Java, Clojure, Node.js, Go + binary code Python, Ruby, Java, Node.js Python Ruby


We Work Where You Work



IronWorker runs on top of the major clouds, and can be included as an add-on with popular platform providers.


Aws
Rackspace
Heroku
Openshift
Pivotal
Appfog
Signup

Get Started Now

Try all features free for 30 days. No credit card required to start.

Sign Up
Whitepaper

Download the Whitepaper

Read about the Top 10 uses of IronWorker to learn the power of async task processing.

Download
Docs

Read the Docs

Check out our extensive documentation to learn the ins and outs of IronWorker.

Learn More

Stay Up To Date With the Latest News, Tips & Tricks