September 3, 2025 16 min to read

Deep Dive into OpenStack Manila

Understanding OpenStack's Shared File System as a Service

Understanding OpenStack Manila

Manila is OpenStack’s Shared File System as a Service (SFaaS) that provides file sharing capabilities across multiple virtual machines and containers.

It supports various file sharing protocols like NFS and CIFS, enabling flexible and scalable file storage solutions in the cloud.

What is Manila?

The Shared File System Service

Manila serves as OpenStack’s file sharing service, providing essential functionality:

• File Sharing: Enables multiple VMs and containers to access shared storage simultaneously
• Protocol Support: Supports industry-standard protocols including NFS, CIFS/SMB, HDFS, and CephFS
• Multi-tenancy: Provides secure isolated file systems for different projects and users
• Storage Management: Manages complete file system lifecycle including creation, snapshots, and replication
• Enterprise Integration: Seamless integration with existing enterprise storage solutions

By providing shared file system capabilities, Manila enables efficient data sharing and collaboration in cloud environments while maintaining security and performance.

Why Use Manila?

Manila addresses critical challenges in cloud storage management:

• Shared Storage: Multiple instances can access the same data simultaneously
• Protocol Flexibility: Support for various file sharing protocols meets diverse application needs
• Scalability: Dynamic scaling of file systems based on demand
• Data Persistence: Persistent storage that survives instance lifecycle
• Enterprise Ready: Integration with enterprise storage arrays and NAS devices
• Cost Efficiency: Optimized resource utilization through shared access

Supported File System Types

Manila supports various file system types and protocols:

Manila Architecture Overview (Diagram Description)

• Core Features: File Sharing, Multi-tenancy, Access Control
• Service Integration: Nova, Neutron, Keystone
• Storage: Backend Storage, Snapshots, Replication
• Protocols: NFS, CIFS, CephFS

Manila Architecture and Components

Manila’s architecture is designed to provide flexible and scalable file sharing capabilities.

Each component plays a specific role in managing and providing access to shared file systems.

Detailed Architecture

Manila follows a distributed architecture with clear separation of responsibilities:

Core Components

Storage Backend Types

Manila supports multiple storage backend architectures:

Service Integration

Manila integrates seamlessly with several OpenStack services to provide comprehensive file sharing:

This comprehensive integration enables robust file sharing within the complete OpenStack ecosystem.

Key Features and Capabilities

Manila provides comprehensive file sharing capabilities that enable efficient data sharing and collaboration.

These features make it a powerful tool for file system management in OpenStack environments.

Core Features

Best Practices

Key considerations for Manila deployment and operation:

Share Types and Capabilities

Understanding share types is crucial for optimal Manila deployment:

These practices ensure reliable, secure, and maintainable file sharing in production environments.

Implementation and Usage

Effective implementation of Manila requires proper configuration and integration with other OpenStack services.

Here are key considerations and best practices for utilizing Manila effectively.

Configuration and Setup

Basic Configuration

Key configuration files and settings:

# /etc/manila/manila.conf
[DEFAULT]
# API Configuration
osapi_share_listen = 0.0.0.0
osapi_share_listen_port = 8786
api_paste_config = /etc/manila/api-paste.ini

# Database Configuration
sql_connection = mysql+pymysql://manila:password@localhost/manila

# RabbitMQ Configuration
transport_url = rabbit://manila:password@controller:5672/

# Keystone Authentication
auth_strategy = keystone

[keystone_authtoken]
www_authenticate_uri = http://controller:5000
auth_url = http://controller:5000
memcached_servers = controller:11211
auth_type = password
project_domain_name = default
user_domain_name = default
project_name = service
username = manila
password = manila_password

# Share Backend Configuration
enabled_share_backends = generic,cephfs,netapp
enabled_share_protocols = NFS,CIFS,CEPHFS

[generic]
share_driver = manila.share.drivers.generic.GenericShareDriver
interface_driver = manila.network.linux.interface.OVSInterfaceDriver
service_instance_flavor_id = 100
service_image_name = manila-service-image
service_instance_user = manila
service_instance_password = manila
connect_share_server_to_tenant_network = True

[cephfs]
share_driver = manila.share.drivers.cephfs.driver.CephFSDriver
driver_handles_share_servers = False
cephfs_conf_path = /etc/ceph/ceph.conf
cephfs_auth_id = manila
cephfs_cluster_name = ceph

Advanced Backend Configuration

Example configuration for enterprise storage arrays:

# NetApp ONTAP Backend
[netapp]
share_driver = manila.share.drivers.netapp.dataontap.cluster_mode.drv.NetAppCmodeMultiSVMShareDriver
driver_handles_share_servers = True
netapp_server_hostname = 192.168.1.100
netapp_server_port = 443
netapp_login = admin
netapp_password = password
netapp_vserver = manila_vserver
netapp_aggregate_name_search_pattern = ^aggr.*
netapp_root_volume_aggregate = aggr1
netapp_port_name_search_pattern = ^e.*

Share Network Management

Creating Share Networks

Share networks provide network connectivity for shares:

Security Services

Configure authentication and access control:

Advanced Usage Examples

Share Replication Setup

Configure disaster recovery with share replication:

Share Groups Management

Manage related shares as a group:

Mount Share Examples

Examples of mounting shares on different platforms:

API Usage Examples

Using REST API

Direct API calls for automation and integration:

Python Client Usage

Programmatic access using Python Manila client:

from manilaclient import client
from keystoneauth1.identity import v3
from keystoneauth1 import session

# Authentication
auth = v3.Password(
    auth_url='http://keystone.example.com:5000/v3',
    username='admin',
    password='password',
    project_name='admin',
    user_domain_name='default',
    project_domain_name='default'
)
sess = session.Session(auth=auth)
manila = client.Client('2', session=sess)

# Create share
share = manila.shares.create(
    share_proto='NFS',
    size=100,
    name='python-share',
    share_type='default',
    share_network='<share-network-id>'
)

# Wait for share to be available
manila.shares.wait_for_share_to_become_available(share.id)

# Allow access
manila.shares.allow(
    share.id,
    access_type='ip',
    access='192.168.1.0/24',
    access_level='rw'
)

# Create snapshot
snapshot = manila.share_snapshots.create(
    share.id,
    name='python-snapshot',
    description='Created via Python client'
)

# List shares
shares = manila.shares.list()
for share in shares:
    print(f"Share: {share.name}, Status: {share.status}, Size: {share.size}GB")

Use Cases

Manila is particularly useful for various enterprise and cloud scenarios:

These use cases demonstrate Manila’s versatility and enterprise readiness across various deployment scenarios.

Monitoring and Troubleshooting

Effective monitoring and troubleshooting are essential for maintaining reliable Manila file sharing services.

Performance Monitoring

Key Metrics to Monitor

Log Analysis

Key log files and monitoring patterns:

# Manila service logs
tail -f /var/log/manila/manila-api.log
tail -f /var/log/manila/manila-scheduler.log
tail -f /var/log/manila/manila-share.log
tail -f /var/log/manila/manila-data.log

# Key patterns to monitor:
# - Share creation/deletion operations
# - Access rule modifications
# - Backend communication errors
# - Network connectivity issues
# - Authentication failures

Common Issues and Solutions

Troubleshooting Guide

Performance Optimization

Strategies for optimizing Manila performance:

• Network Optimization: Use dedicated networks for storage traffic
• Backend Tuning: Optimize storage array settings
• Share Server Sizing: Right-size share server instances
• Protocol Selection: Choose optimal protocols for workloads
• Caching: Implement client-side caching where appropriate

Security and Access Control

Comprehensive security guidelines for Manila deployments in production environments.

Access Control Models

Access Types

Manila supports multiple access control mechanisms:

Security Services Integration

Configure enterprise authentication:

Network Security

Best practices for securing Manila network traffic:

• Network Isolation: Use dedicated share networks
• VLAN Segmentation: Separate storage traffic from general network
• Firewall Rules: Restrict access to necessary ports only
• VPN Access: Use VPN for remote access to shares
• Encryption: Enable encryption in transit where supported

Data Protection

Comprehensive data protection strategies:

• Encryption at Rest: Use backend encryption capabilities
• Snapshot Policies: Regular automated snapshots
• Replication: Cross-site data replication for DR
• Access Auditing: Log and monitor all share access
• Backup Integration: Regular backup to external systems

Key Points

References

• OpenStack Manila Documentation
• Red Hat OpenStack Platform Documentation
• OpenStack Wiki - Manila
• Manila API Reference
• Manila Configuration Reference
• OpenStack Manila Client Documentation
• Manila Driver Documentation
• NFS Protocol Specification
• CIFS/SMB Protocol Documentation
• CephFS Integration Guide
• Manila Security Guide
• OpenStack Shared File System Service Admin Guide