Ansible for Quantum Computing: Deploy Qiskit, Cirq & Hybrid Infrastructure (2026 Guide)
By Luca Berton · Published 2024-01-01 · Category: installation
Complete guide to automating quantum computing infrastructure with Ansible. Deploy Qiskit and Cirq environments, manage hybrid classical-quantum clusters.
Quantum computing is moving from research to enterprise pilots in 2026 — IBM, Google, and Amazon all offer quantum cloud services, and organizations need infrastructure to develop, test, and integrate quantum workloads. Ansible automates the deployment of quantum development environments, simulators, and hybrid classical-quantum pipelines.
Quantum Computing Infrastructure Layers
┌──────────────────────────────────────────┐
│ Quantum Cloud APIs (IBM, AWS, Google) │
├──────────────────────────────────────────┤
│ Hybrid Orchestration Layer │
├──────────────────────────────────────────┤
│ Classical HPC / GPU Simulators │
├──────────────────────────────────────────┤
│ Development Environments (Qiskit/Cirq) │
└──────────────────────────────────────────┘
↑ All layers managed by Ansible ↑See also: Learn Ansible: Complete Beginner's Guide & Learning Path (2026)
Deploy Qiskit Development Environment
- name: Deploy IBM Qiskit quantum development environment
hosts: quantum_dev
become: true
vars:
qiskit_version: "1.3"
python_version: "3.12"
tasks:
- name: Install system dependencies
ansible.builtin.apt:
name:
- python{{ python_version }}
- python{{ python_version }}-venv
- python3-pip
- build-essential
- libopenblas-dev
- liblapack-dev
- gfortran
state: present
update_cache: true
- name: Create quantum development virtualenv
ansible.builtin.pip:
name:
- "qiskit=={{ qiskit_version }}"
- qiskit-aer
- qiskit-ibm-runtime
- qiskit-optimization
- qiskit-machine-learning
- qiskit-nature
- matplotlib
- jupyterlab
- pylatexenc
virtualenv: /opt/quantum/qiskit-env
virtualenv_command: "python{{ python_version }} -m venv"
- name: Deploy IBM Quantum credentials
ansible.builtin.copy:
content: |
{
"default_instance": "ibm-q/open/main",
"urls": {
"https://quantum.ibm.com": {
"token": "{{ vault_ibm_quantum_token }}"
}
}
}
dest: "{{ item }}/.qiskit/qiskit-ibm.json"
mode: '0600'
owner: "{{ item | basename }}"
loop: "{{ quantum_dev_home_dirs }}"
no_log: true
- name: Deploy JupyterLab service for quantum development
ansible.builtin.copy:
content: |
[Unit]
Description=JupyterLab Quantum Development
After=network.target
[Service]
Type=simple
User=quantum-dev
Environment=PATH=/opt/quantum/qiskit-env/bin:/usr/bin
ExecStart=/opt/quantum/qiskit-env/bin/jupyter lab \
--ip=0.0.0.0 --port=8888 --no-browser \
--notebook-dir=/home/quantum-dev/notebooks
Restart=always
[Install]
WantedBy=multi-user.target
dest: /etc/systemd/system/jupyterlab-quantum.service
notify: restart jupyterlab-quantumDeploy Google Cirq Environment
- name: Deploy Google Cirq quantum environment
hosts: quantum_dev
become: true
tasks:
- name: Install Cirq and related packages
ansible.builtin.pip:
name:
- cirq-core
- cirq-google
- cirq-aqt
- cirq-ionq
- tensorflow-quantum
- qsimcirq
virtualenv: /opt/quantum/cirq-env
virtualenv_command: "python3.12 -m venv"
- name: Deploy Google Cloud credentials for quantum
ansible.builtin.copy:
content: "{{ vault_gcp_quantum_sa_key }}"
dest: /etc/quantum/gcp-quantum-sa.json
mode: '0600'
no_log: true
- name: Configure Cirq environment
ansible.builtin.copy:
content: |
export GOOGLE_APPLICATION_CREDENTIALS=/etc/quantum/gcp-quantum-sa.json
export CIRQ_PROCESSOR="{{ gcp_quantum_processor }}"
export CIRQ_PROJECT="{{ gcp_project_id }}"
dest: /etc/profile.d/cirq-env.sh
mode: '0644'See also: Red Hat Summit: Connect 2024 – Future of AI, Cloud, & Automation
Quantum Simulator Cluster
- name: Deploy high-performance quantum simulator cluster
hosts: quantum_simulators
become: true
vars:
simulator_type: "statevector"
max_qubits: 32
gpu_enabled: true
tasks:
- name: Install NVIDIA CUDA for GPU-accelerated simulation
ansible.builtin.apt:
name:
- nvidia-cuda-toolkit
- nvidia-cuda-dev
- libcustatevec0
state: present
when: gpu_enabled
- name: Install Qiskit Aer with GPU support
ansible.builtin.pip:
name:
- qiskit-aer-gpu
virtualenv: /opt/quantum/simulator-env
when: gpu_enabled
- name: Deploy simulator configuration
ansible.builtin.copy:
content: |
simulator:
type: {{ simulator_type }}
max_qubits: {{ max_qubits }}
gpu:
enabled: {{ gpu_enabled }}
memory_limit_gb: {{ gpu_memory_gb | default(16) }}
performance:
threads: {{ ansible_processor_vcpus }}
memory_limit_gb: {{ (ansible_memtotal_mb / 1024 * 0.8) | int }}
fusion_threshold: 14
api:
host: 0.0.0.0
port: 8100
max_concurrent_jobs: {{ max_concurrent_simulations | default(4) }}
dest: /etc/quantum/simulator.yaml
- name: Deploy simulator service
ansible.builtin.template:
src: quantum-simulator.service.j2
dest: /etc/systemd/system/quantum-simulator.service
notify: restart quantum-simulatorHybrid Classical-Quantum Pipeline
- name: Deploy hybrid quantum-classical orchestration
hosts: hybrid_orchestrator
become: true
tasks:
- name: Deploy hybrid pipeline manager
community.docker.docker_container:
name: quantum-orchestrator
image: "{{ quantum_orchestrator_image }}"
state: started
restart_policy: unless-stopped
ports:
- "8200:8200"
volumes:
- /etc/quantum:/config:ro
- /var/quantum/jobs:/jobs
env:
CLASSICAL_BACKEND: "http://hpc-cluster:8080"
QUANTUM_BACKENDS: |
[
{"name": "ibm_brisbane", "type": "ibm", "qubits": 127},
{"name": "local_sim", "type": "aer", "url": "http://sim-01:8100", "qubits": 32},
{"name": "google_rainbow", "type": "cirq", "qubits": 72}
]
JOB_ROUTING: "auto"
FALLBACK_TO_SIMULATOR: "true"
- name: Deploy quantum job routing rules
ansible.builtin.copy:
content: |
routing:
rules:
# Small circuits → local simulator (faster)
- condition:
max_qubits: 20
max_depth: 100
backend: local_sim
priority: 1
# Medium circuits → GPU simulator
- condition:
max_qubits: 32
max_depth: 1000
backend: local_sim_gpu
priority: 2
# Large circuits → real quantum hardware
- condition:
min_qubits: 21
backend: ibm_brisbane
priority: 3
queue_timeout_minutes: 60
fallback:
backend: local_sim
warn: true
retry:
max_attempts: 3
backoff_seconds: [10, 30, 120]
dest: /etc/quantum/routing.yamlSee also: Ansible for AI Infrastructure: Deploy LLMs, GPUs & ML Pipelines (2026 Guide)
Quantum-Safe Key Generation
- name: Deploy quantum random number generation
hosts: crypto_servers
become: true
tasks:
- name: Install QRNG client
ansible.builtin.pip:
name:
- qiskit
- qiskit-ibm-runtime
virtualenv: /opt/quantum/qrng-env
- name: Deploy QRNG service
ansible.builtin.copy:
content: |
#!/usr/bin/env python3
"""Quantum Random Number Generator Service"""
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
import json, sys
def generate_random_bits(n_bits=256):
qc = QuantumCircuit(min(n_bits, 32), min(n_bits, 32))
for i in range(min(n_bits, 32)):
qc.h(i)
qc.measure_all()
simulator = AerSimulator()
result = simulator.run(qc, shots=1).result()
counts = result.get_counts()
bits = list(counts.keys())[0]
return bits
if __name__ == "__main__":
n = int(sys.argv[1]) if len(sys.argv) > 1 else 256
print(generate_random_bits(n))
dest: /opt/quantum/qrng-service.py
mode: '0755'
- name: Schedule quantum entropy harvesting
ansible.builtin.cron:
name: "Quantum entropy harvest"
minute: "*/5"
job: "/opt/quantum/qrng-env/bin/python /opt/quantum/qrng-service.py 256 >> /var/lib/quantum-entropy/pool.bin"
user: quantum-entropyMonitoring Quantum Workloads
- name: Monitor quantum infrastructure
hosts: quantum_dev:quantum_simulators
tasks:
- name: Check simulator health
ansible.builtin.uri:
url: "http://{{ inventory_hostname }}:8100/health"
method: GET
return_content: true
register: sim_health
when: "'quantum_simulators' in group_names"
- name: Check IBM Quantum queue depth
ansible.builtin.command: >
/opt/quantum/qiskit-env/bin/python -c "
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
for backend in service.backends():
status = backend.status()
if status.pending_jobs > 10:
print(f'⚠️ {backend.name}: {status.pending_jobs} pending jobs')
"
register: queue_check
changed_when: false
delegate_to: "{{ groups['quantum_dev'][0] }}"
run_once: true
- name: Report queue status
ansible.builtin.debug:
msg: "{{ queue_check.stdout_lines }}"
when: queue_check.stdout | length > 0FAQ
Can Ansible manage quantum computers?
Ansible manages the classical infrastructure around quantum computing: development environments, simulators, hybrid orchestrators, credential management, and monitoring. Actual quantum circuit execution happens through SDKs (Qiskit, Cirq) deployed and configured by Ansible.
What is a hybrid classical-quantum pipeline?
A hybrid pipeline routes computational tasks to either classical computers or quantum processors based on problem characteristics. Ansible deploys the orchestration layer that decides which backend handles each job, manages queuing, and handles fallback to simulators when quantum hardware is unavailable.
How many qubits can simulators handle?
GPU-accelerated simulators handle up to 32-34 qubits on a single node. Beyond that, you need distributed simulation or real quantum hardware. Ansible manages simulator clusters and automatically routes large circuits to appropriate backends.
Should enterprises start quantum infrastructure now?
Yes — for development and experimentation. Deploy simulators and development environments now so teams build quantum skills. Ansible makes this low-risk: automated setup, consistent environments, and easy scaling from simulators to real quantum backends as hardware matures.
Conclusion
Quantum computing infrastructure in 2026 requires the same automation discipline as classical IT. Ansible deploys quantum development environments (Qiskit, Cirq), manages simulator clusters, orchestrates hybrid classical-quantum pipelines, and monitors quantum workloads — giving enterprises a reproducible, auditable path to quantum readiness.
Related Articles
Category: installation