Software Engineer

Building Asynchronous Instagram Automation with Symfony Messenger

6 min read

Aug 9, 2025

Poster of Boston Code and Coffee talk for Instagram automation.

Introduction to Asynchronous Messaging

In modern web applications, not every task needs to happen immediately. When a user uploads a file, sends an email, or publishes content to social media, these operations can take time and shouldn't block the main application flow. This is where asynchronous messaging comes into play.

Asynchronous messaging is a communication pattern where tasks are queued for later processing rather than executed immediately. Think of it like dropping a letter in a mailbox instead of hand-delivering it—you don't wait around for the delivery to complete. This approach offers several key benefits:

Improved User Experience: Users don't wait for slow operations to complete
Better Resource Management: Heavy tasks run during off-peak hours
Increased Reliability: Failed tasks can be retried automatically
Scalability: Multiple workers can process messages in parallel

Key Components of Message-Based Systems

Message: A data structure containing information about a task to be performed
Queue: A storage mechanism that holds messages until they're processed
Producer: The component that creates and dispatches messages
Consumer: The worker that retrieves and processes messages
Message Bus: The transport layer that routes messages between producers and consumers

Popular tools for implementing message queues include RabbitMQ, Apache Kafka, Redis, and AWS SQS. In our example, we'll use Symfony Messenger with Doctrine, which stores messages in a database table.

What is Symfony?

Symfony is a robust PHP web application framework that provides reusable components and a structured architecture for building scalable applications. Created by SensioLabs and first released in 2005, Symfony has become one of the most popular PHP frameworks, powering platforms like Drupal, Laravel, and Magento.

Why Symfony?

Component-Based: Use only what you need
Enterprise-Ready: Battle-tested in large-scale applications
Excellent Documentation: Comprehensive guides and best practices
Strong Community: Active development and support
Modern PHP: Leverages the latest PHP features

Installing Symfony

To get started with Symfony, you'll need PHP 8.1 or higher and Composer installed on your system.

# Install Symfony CLI (recommended)
curl -sS https://get.symfony.com/cli/installer | bash

# Create a new Symfony project
symfony new my_project --webapp

# Or using Composer directly
composer create-project symfony/skeleton my_project
cd my_project
composer require webapp

Installing Required Packages

For our Instagram automation project, we need several Symfony components:

# Core messaging component
composer require symfony/messenger

# Database integration
composer require symfony/orm-pack

# Email functionality
composer require symfony/mailer

# AWS SES integration (optional)
composer require symfony/amazon-mailer

# Templating engine
composer require symfony/twig-bundle

# Logging
composer require symfony/monolog-bundle

Project Structure

A typical Symfony project follows this structure:

project/
├── bin/
│   └── console          # CLI commands
├── config/              # Configuration files
├── public/              # Web root
├── src/
│   ├── Command/         # Console commands
│   ├── Controller/      # HTTP controllers
│   ├── Message/         # Message classes
│   └── MessageHandler/  # Message processors
├── var/                 # Cache and logs
└── .env                 # Environment variables

Understanding the Instagram Automation Workflow

Our application automates Instagram posting through an asynchronous workflow:

Schedule Creation: A cron job triggers the creation command
Image Generation: A quote image is generated dynamically
Message Dispatch: An Instagram post message is queued
Message Processing: A worker consumes the message
API Interaction: The post is published to Instagram
Notification: An email confirms the successful post

Let's examine the key components in detail.

Key Code Components

1. The Message Class: InstagramPostMessage

The message class is a simple data transfer object (DTO) that carries information about the Instagram post:

namespace App\Message;

class InstagramPostMessage
{
    public function __construct(
        private int $id, 
        private string $title, 
        private string $image_filename
    ) {}

    public function getId(): int
    {
        return $this->id;
    }

    public function getTitle(): string
    {
        return $this->title;
    }

    public function getImageFilename(): string
    {
        return $this->image_filename;
    }
}

Key Points:

Uses PHP 8's constructor property promotion for concise code
Immutable by design—no setters, only getters
Contains only essential data needed for processing
Serializable for storage in the message queue

2. Creating Messages: InstagramPostCommand

The command creates a new post message and dispatches it to the queue:

protected function execute(InputInterface $input, OutputInterface $output): int
{
    $image_filename = $this->createImage();
    $this->bus->dispatch(new InstagramPostMessage(
        1, 
        'Title ' . $image_filename, 
        $image_filename
    ));
    $output->writeln('Created instagram post creation message:' . $image_filename);
    return Command::SUCCESS;
}

protected function createImage(): string
{
    $generator = new InstagramQuoteGenerator();
    $image_name = 'post_' . time() . '.png';
    $imagePath = $generator->createQuoteImage(
        null,  // Random quote
        null,  // Random gradient
        'public/images/' . $image_name,
        [
            'font_size' => 72,
            'font_path' => 'public/fonts/RobotoSlab.ttf',
            'border_width' => 25
        ]
    );
    return $image_name;
}

How it Works:

Image Generation: Creates a beautiful gradient quote image with random content
Message Creation: Instantiates a new InstagramPostMessage with the image filename
Dispatch: $this->bus->dispatch() sends the message to the configured transport (database)
Non-Blocking: The command completes immediately without waiting for Instagram API calls

3. Processing Messages: InstagramPostMessageHandler

The handler is where the actual work happens—it consumes messages from the queue and publishes to Instagram:

#[AsMessageHandler]
class InstagramPostMessageHandler
{
    public function __construct(
        private Connection $connection,
        private MailerInterface $mailer,
        private KernelInterface $kernel,
        private LoggerInterface $logger
    ) {}

    public function __invoke(InstagramPostMessage $message)
    {
        $this->logger->info("Sending post ID: " . $message->getId() . 
                           " title:" . $message->getTitle() . 
                           " url:" . $message->getImageFilename());
        $this->createPost($message->getImageFilename());
    }
}

Key Concepts:

Attribute-Based Configuration: #[AsMessageHandler] auto-registers this class
Dependency Injection: All dependencies provided via constructor
Invokable Class: The __invoke() magic method is called when processing
Type Hinting: Symfony knows which messages this handler processes by the type hint

4. Instagram API Integration

The createPost() method handles the two-step Instagram publishing process:

private function createPost($image_filename)
{
    $client = HttpClient::create();
    $image_url = $_ENV['REMOTE_HOST'] . "/images/" . $image_filename;
    $caption = "My comments\n\n #good #nice";
    
    // Step 1: Create media container
    $container_json = [
        "caption" => $caption,
        "image_url" => $image_url
    ];
    
    $response = $client->request('POST', $container_url, [
        'headers' => $headers,
        'json' => $container_json
    ]);
    
    if ($response->getStatusCode() === Response::HTTP_OK) {
        $data = $response->toArray();
        $media_id = $data["id"];
        
        // Step 2: Publish the container
        $response = $client->request('POST', $publish_url, [
            'headers' => $headers,
            'json' => ["creation_id" => $media_id]
        ]);
        
        if ($response->getStatusCode() === Response::HTTP_OK) {
            $this->sendEmailNotification([
                "date" => date("Y-m-d"),
                "url" => $image_url
            ]);
        }
    }
}

Instagram API Flow:

Container Creation: Register the image URL and caption with Instagram
Media ID Retrieval: Instagram returns a container ID
Publishing: Use the container ID to publish the post
Notification: Send confirmation email on success

The Instagram Graph API requires a two-step process to ensure images are accessible and valid before publishing.

5. Image Generation: InstagramQuoteGenerator

The InstagramQuoteGenerator class creates visually appealing 1080x1350px Instagram posts with gradient backgrounds:

public function createQuoteImage(
    ?string $quote = null, 
    ?array $gradientColors = null, 
    string $outputPath = null, 
    array $options = []
): string {
    // Create 1080x1350 canvas
    $image = imagecreatetruecolor(self::WIDTH, self::HEIGHT);
    
    // Apply gradient background
    $this->createGradient($image, $gradientColors, $options['gradient_direction']);
    
    // Add decorative border
    $this->addBorder($image, $options);
    
    // Render centered text
    $this->addQuoteText($image, $quote, $options);
    
    // Save as PNG
    imagepng($image, $outputPath, 9);
    imagedestroy($image);
    
    return $outputPath;
}

Features:

Dynamic Gradients: Diagonal, horizontal, vertical, or radial color transitions
Text Wrapping: Automatically fits text within margins
Perfect Centering: Both horizontal and vertical alignment
Drop Shadows: Improves text readability
Customizable Styling: Fonts, colors, borders, and spacing

The generator uses PHP's GD library to create professional-looking social media graphics programmatically.

Configuring Message Transport

In .env, we configure how messages are stored:

# Doctrine transport stores messages in database
MESSENGER_TRANSPORT_DSN=doctrine://default?auto_setup=0

# Alternatives:
# MESSENGER_TRANSPORT_DSN=amqp://guest:guest@localhost:5672/%2f/messages
# MESSENGER_TRANSPORT_DSN=redis://localhost:6379/messages

The Doctrine transport creates a messenger_messages table that acts as our queue.

Scheduling with Cron

To automate the entire workflow, we use Linux cron jobs:

# Edit crontab
crontab -e

# Create post message daily at 10:20 AM
20 10 * * * cd /home/myuser/myapp.com && php bin/console app:instagram-post

# Process messages daily at 10:30 AM (run for 60 seconds)
30 10 * * * cd /home/myuser/myapp.com && php bin/console messenger:consume instagram --time-limit=60

Cron Breakdown:

First job: Creates the message (fast operation)
Second job: Processes queued messages with a time limit
10-minute gap ensures the message is ready to process

Running the Worker Manually

For development or testing, you can process messages manually:

# Process all messages in the instagram queue
php bin/console messenger:consume instagram

# Process with limits
php bin/console messenger:consume instagram --time-limit=60
php bin/console messenger:consume instagram --memory-limit=128M
php bin/console messenger:consume instagram --limit=10

Monitoring Messages

The application includes a monitoring endpoint to view queue status:

#[Route('/messages', name: 'app_messages')]
public function messages(Connection $connection): Response
{
    $sql = 'SELECT * FROM messenger_messages ORDER BY created_at DESC';
    $result = $connection->executeQuery($sql);
    $messages = $result->fetchAllAssociative();
    
    return new JsonResponse($processedMessages);
}

Access this at /messages to see pending, processing, and failed messages.

Error Handling and Retries

Symfony Messenger automatically retries failed messages. Configure retry behavior in config/packages/messenger.yaml:

framework:
    messenger:
        transports:
            instagram:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                retry_strategy:
                    max_retries: 3
                    delay: 1000
                    multiplier: 2

This configuration retries failed messages 3 times with exponential backoff (1s, 2s, 4s).

Conclusion

Asynchronous messaging transforms how we build web applications, enabling:

Decoupled Architecture: Separate concerns into independent components
Improved Reliability: Retry failed operations automatically
Better Performance: Don't block user requests with slow operations
Scalability: Add more workers as your load increases

Our Instagram automation demonstrates these principles in action—combining scheduled tasks, message queuing, image generation, API integration, and email notifications into a robust, production-ready system.

The beauty of Symfony Messenger is its simplicity: create a message class, dispatch it, write a handler, and let the framework handle the rest. Whether you're processing payments, sending emails, generating reports, or publishing to social media, this pattern scales from simple tasks to complex workflows.