Unleash Scalable Code Execution with Piston Workers: A Comprehensive Guide

Need to execute code reliably and at scale? Discover how to use Piston workers with Slurm and Docker to power your applications. We'll cover deployment, configuration, and optimization, so you can achieve peak performance.

What are Piston Workers?

Piston workers are specialized units designed to execute code snippets or "jobs." They provide a controlled and isolated environment, crucial for tasks like:

• Online code execution: Run user-submitted code in a safe sandbox.
• Automated testing: Execute test suites against different environments.
• **Backend processing`: Offload computationally intensive tasks from your main application.

Piston Workers with Slurm: Scaling for High-Performance Computing

Slurm is a powerful, open-source cluster management and job scheduling system. Combine it with Piston to efficiently distribute code execution across a cluster.

Key Benefits:

• Scalability: Easily launch and manage hundreds or thousands of Piston workers.
• Resource Management: Slurm intelligently allocates resources, preventing overload.
• Fault Tolerance: Workers can be automatically restarted in case of failures.

Setting Up Slurm Piston Workers

1. Adapt Launch Scripts: Modify launch_piston_workers.sh and launch_single_piston.sh to match your Slurm environment and desired number of workers.

2. Launch Workers: Execute slurm/piston/launch_piston_workers.sh (number of workers). Each worker will be named like piston-worker-<port>.

   • Example: slurm/piston/launch_piston_workers.sh 5 will create five Piston workers.

3. Install Necessary Packages: This will allow workers to properly execute code.

Initial Package Installation

1. Launch a single Piston worker using slurm/piston/launch_piston_workers.sh 1.

2. Assuming it runs on ip-10-53-86-146:1234, install the IOI package in the worker using cURL (or any other http client):

   curl -X POST http://ip-10-53-86-146:1234/api/v2/packages -H " Content-Type: application/json " -d ' {"language": "cms_ioi", "version": "1.0.0"} '
   

   Copy

Subsequent workers should automatically have the package thanks to the shared, mounted packages directory.

Configuring Piston Endpoints

To enable the main script to discover workers automatically, declare the following environment variable, either through the command line, or in .env config:

export PISTON_ENDPOINTS=slurm

Piston Workers with Docker: Quick and Isolated Deployments

Docker provides a lightweight, containerized environment, perfect for running Piston workers in isolation.

Advantages:

• Isolation: Each worker runs in its own container, preventing interference.
• Reproducibility: Simplify deployment by ensuring consistent environments across machines.
• Portability: Easily move workers between different Docker-enabled platforms.

Launching a Piston Worker with Docker

Use the following docker run command, modifying paths and ports as needed:

docker run -d \
--name piston_worker \
-v /path/to/local/packages:/piston/packages \
-e PORT=2000 \
-e PISTON_COMPILE_TIMEOUT=60000 \
-e PISTON_RUN_TIMEOUT=60000 \
-e PISTON_OUTPUT_MAX_SIZE=1000000000 \
-e PISTON_MAX_FILE_SIZE=1000000000 \
-e PISTON_DISABLE_NETWORKING=true \
-e PISTON_REPO_URL=https://github.com/guipenedo/piston/releases/download/pkgs/index \
-p 2000:2000 \
--entrypoint /bin/bash \
ghcr.io/engineer-man/piston@sha256:63b5654156a89c5a2ad281aface21416615d62ec056d88efe8fcd307ce73575a \
-c " sed -i '/app.use(body_parser.urlencoded/c\ app.use(body_parser.urlencoded({ extended: true, limit: \" 512mb \"}));' src/index.js && \
sed -i '/app.use(body_parser.json/c\ app.use(body_parser.json({ limit: \" 512mb \"}));' src/index.js && \
node src "

• -v /path/to/local/packages:/piston/packages: Sets the shared directory for packages.
• -e ...: Configure environment variables for timeouts, output sizes, and networking.
• -p 2000:2000: Maps port 2000 on the host to port 2000 in the container.

Installing Packages in Your Dockerized Worker

After launching the container, install packages using curl:

curl -X POST http://localhost:2000/api/v2/packages -H " Content-Type: application/json " -d ' {"language": "cms_ioi", "version": "1.0.0"} '

Connecting to Multiple Docker Piston Endpoints

Configure Piston to use your Docker workers by setting the PISTON_ENDPOINTS environment variable:

export PISTON_ENDPOINTS=http://localhost:2000/api/v2,http://localhost:2001/api/v2,http://localhost:2002/api/v2

Optimizing Piston Worker Performance

• PISTON_MAX_REQUESTS_PER_ENDPOINT: Limit the number of simultaneous requests a worker handles. This helps prevent overloading and improves responsiveness. Default is 1.
• Timeouts: Configure PISTON_COMPILE_TIMEOUT and PISTON_RUN_TIMEOUT based on the expected execution time of your jobs.
• Resource Limits: Fine-tune PISTON_OUTPUT_MAX_SIZE and PISTON_MAX_FILE_SIZE to prevent resource exhaustion.
• Networking: Disable networking (PISTON_DISABLE_NETWORKING=true) if your workers don't need external network access for enhanced security.
• Package Management: Store packages in a shared/mounted directory to reduce installation overhead when launching new workers.

Beyond Piston: Adaptable Code Execution

Piston is an amazing tool, but there are also other options, such as the "ioi repo". Be sure to search and explore other options to find the best fit for your setup.

Conclusion

By leveraging Piston workers with Slurm or Docker, you can create a robust and scalable code execution environment. Optimize your configurations, explore advanced features, and unlock the full potential of your workflows.