Deploying Mixpost

Introduction

Mixpost is a self-hosted social media management platform that enables you to schedule and publish content across multiple social networks from a single dashboard. Built with Laravel and Vue.js, Mixpost provides a clean, intuitive interface for managing your social media presence without relying on third-party SaaS platforms.

The application supports major social networks including Twitter/X, Facebook, Instagram, LinkedIn, Pinterest, and Mastodon. With features like bulk scheduling, content calendars, and team collaboration, Mixpost serves both individual creators and marketing teams.

Key highlights of Mixpost:

• Multi-Platform Publishing: Connect and manage multiple social accounts
• Content Scheduling: Plan posts in advance with calendar view
• Visual Calendar: See your content schedule at a glance
• Media Library: Store and organize images and videos
• Queue Management: Auto-schedule posts at optimal times
• Post Templates: Save and reuse content formats
• Team Workspaces: Collaborate with team members
• Analytics Dashboard: Track post performance metrics
• Hashtag Management: Save and organize hashtag groups
• Draft System: Work on posts before scheduling
• Bulk Actions: Schedule multiple posts efficiently
• API Access: Integrate with other tools and workflows
• Self-Hosted: Full control over your data and privacy

This guide covers deploying Mixpost on Klutch.sh, connecting social accounts, and configuring the platform for your content workflow.

Why Deploy Mixpost on Klutch.sh

Deploying Mixpost on Klutch.sh provides significant advantages:

Simplified Deployment: Klutch.sh automatically builds and deploys Mixpost from your Dockerfile. Push to GitHub, and your social media manager deploys automatically.

Persistent Storage: Attach volumes for media files, database, and configurations that persist across updates.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, required for OAuth callbacks from social platforms.

GitHub Integration: Connect your repository for automatic deployments on updates.

Scalable Resources: Allocate CPU and memory based on media processing needs and scheduled post volume.

Environment Variable Management: Securely store API keys and OAuth credentials.

Custom Domains: Use your own domain for professional OAuth redirect URLs.

Always-On Availability: Your social media manager runs 24/7 to publish scheduled posts on time.

Prerequisites

Before deploying Mixpost on Klutch.sh, ensure you have:

• A Klutch.sh account
• A GitHub account with a repository for your configuration
• Basic familiarity with Docker and containerization
• Developer accounts for social platforms you want to connect
• (Optional) A custom domain for OAuth redirect URLs
• MySQL/MariaDB database (can be provisioned on Klutch.sh)

Understanding Mixpost Architecture

Mixpost consists of several components:

Laravel Backend: Handles authentication, API integrations, and scheduling logic.

Vue.js Frontend: Provides the interactive user interface.

MySQL Database: Stores posts, schedules, accounts, and user data.

Redis: Queue management for scheduled posts and background jobs.

Queue Worker: Processes scheduled posts and media operations.

Scheduler: Triggers post publishing at scheduled times.

Preparing Your Repository

Repository Structure

mixpost-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile:

FROM inovector/mixpost:latest

# Environment configuration
ENV APP_KEY=${APP_KEY}
ENV APP_URL=${APP_URL}
ENV DB_CONNECTION=mysql
ENV DB_HOST=${DB_HOST}
ENV DB_DATABASE=${DB_DATABASE}
ENV DB_USERNAME=${DB_USERNAME}
ENV DB_PASSWORD=${DB_PASSWORD}
ENV REDIS_HOST=${REDIS_HOST}
ENV REDIS_PASSWORD=${REDIS_PASSWORD}

# Social platform credentials
ENV TWITTER_CLIENT_ID=${TWITTER_CLIENT_ID}
ENV TWITTER_CLIENT_SECRET=${TWITTER_CLIENT_SECRET}
ENV FACEBOOK_CLIENT_ID=${FACEBOOK_CLIENT_ID}
ENV FACEBOOK_CLIENT_SECRET=${FACEBOOK_CLIENT_SECRET}

# Create directories
RUN mkdir -p /var/www/html/storage/app/public

# Expose port
EXPOSE 80

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f http://localhost/ || exit 1

Environment Variables Reference

Variable	Required	Default	Description
APP_KEY	Yes	-	Laravel application key
APP_URL	Yes	-	Public URL of your Mixpost instance
DB_HOST	Yes	-	MySQL database host
DB_DATABASE	Yes	-	Database name
DB_USERNAME	Yes	-	Database username
DB_PASSWORD	Yes	-	Database password
REDIS_HOST	Yes	-	Redis server host
REDIS_PASSWORD	No	-	Redis password if required
TWITTER_CLIENT_ID	No	-	Twitter API client ID
TWITTER_CLIENT_SECRET	No	-	Twitter API client secret
FACEBOOK_CLIENT_ID	No	-	Facebook App ID
FACEBOOK_CLIENT_SECRET	No	-	Facebook App secret

Deploying Mixpost on Klutch.sh

Generate Application Key

Create a Laravel application key:

php artisan key:generate --show

Or generate a random 32-character string:

openssl rand -base64 32

Provision Database and Redis

Set up MySQL and Redis instances. Note your connection details.

Push Your Repository to GitHub

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Mixpost deployment"
git remote add origin https://github.com/yourusername/mixpost-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a project named “mixpost” or “social-manager”.

Create a New App

Create a new app and connect your GitHub repository.

Configure HTTP Traffic

In deployment settings:

• Select HTTP as the traffic type
• Set the internal port to 80

Set Environment Variables

Configure your environment:

Variable	Value
APP_KEY	Your generated Laravel key
APP_URL	https://your-app-name.klutch.sh
DB_HOST	Your MySQL host
DB_DATABASE	mixpost
DB_USERNAME	Your database user
DB_PASSWORD	Your database password
REDIS_HOST	Your Redis host

Attach Persistent Volumes

Add volumes for persistent data:

Mount Path	Recommended Size	Purpose
/var/www/html/storage	20 GB	Media files and cache
/var/www/html/public/storage	10 GB	Public media assets

Deploy Your Application

Click Deploy to build and launch Mixpost.

Run Migrations

After deployment, run database migrations:

php artisan migrate

Create Admin User

Create your admin account:

php artisan mixpost:create-user

Access Mixpost

Navigate to https://your-app-name.klutch.sh and log in.

Connecting Social Accounts

Twitter/X Integration

1. Create a Twitter Developer account
2. Create a new app in Twitter Developer Portal
3. Enable OAuth 2.0 with PKCE
4. Set callback URL: https://your-mixpost.com/callback/twitter
5. Add credentials to environment variables

Facebook/Instagram Integration

1. Create a Facebook Developer account
2. Create a new app with Instagram permissions
3. Configure OAuth redirect URL
4. Add App ID and secret to environment

LinkedIn Integration

1. Create a LinkedIn Developer app
2. Configure OAuth 2.0 settings
3. Set redirect URL
4. Add client credentials

Mastodon Integration

1. Create app on your Mastodon instance
2. Get application credentials
3. Configure in Mixpost settings

Using Mixpost

Creating Posts

1. Click Create Post
2. Select target social accounts
3. Write your content (each platform can have unique text)
4. Add media from library or upload new
5. Set schedule or publish immediately

Calendar View

The calendar provides a visual overview:

• See all scheduled posts by day/week/month
• Drag and drop to reschedule
• Click posts to edit
• Identify gaps in your schedule

Queue Management

Set up automatic scheduling:

1. Define time slots for auto-scheduling
2. Add posts to queue
3. Mixpost fills available slots

Media Library

Organize your assets:

• Upload images and videos
• Create folders for organization
• Search and filter media
• Reuse across posts

Team Collaboration

Creating Workspaces

Organize by brand or project:

1. Navigate to Workspaces
2. Create new workspace
3. Add team members
4. Connect relevant social accounts

User Roles

• Owner: Full access to all features
• Admin: Manage users and settings
• Editor: Create and schedule posts
• Author: Create drafts only

Troubleshooting

Posts Not Publishing

• Verify queue worker is running
• Check social account connections
• Review scheduled post logs
• Ensure system time is correct

OAuth Callback Errors

• Verify APP_URL matches your domain
• Check redirect URL configuration in social apps
• Ensure HTTPS is working

Media Upload Issues

• Check storage volume permissions
• Verify sufficient disk space
• Review file size limits

Slow Performance

• Ensure Redis is connected
• Check database query performance
• Monitor queue worker health

Additional Resources

• Mixpost Official Website
• Mixpost Documentation
• Mixpost GitHub Repository
• Laravel Documentation
• Klutch.sh Persistent Volumes
• Klutch.sh Deployments

Conclusion

Mixpost on Klutch.sh provides a powerful, self-hosted alternative to commercial social media management tools. With support for major platforms, visual scheduling, and team collaboration, Mixpost delivers the features needed for professional social media management. The self-hosted approach ensures data privacy and eliminates subscription costs, while Klutch.sh handles the deployment complexity, letting you focus on creating and scheduling content.