← Back to Frameworks

IBM Cloud

Cloud PlatformRed Hat OpenShiftWatson AIHybrid CloudEnterpriseKubernetes

Cloud Platform

IBM Cloud

Overview

IBM Cloud is IBM's enterprise-focused hybrid multi-cloud platform. Built around core technologies like Red Hat OpenShift, Watson AI, and blockchain solutions, it sees growing adoption among large enterprises, financial institutions, and government organizations. IBM Cloud integrates IBM's decades of enterprise experience with Red Hat OpenShift's advanced container platform technology to provide comprehensive cloud services.

Details

IBM Cloud launched its services in 2013 and now operates across more than 60 locations worldwide. It excels in IBM-specific technologies including Red Hat OpenShift, Watson AI, IBM Z (mainframe), and Db2, leading the industry in hybrid cloud and multi-cloud strategies. Key 2025 features include the general availability of Red Hat OpenShift Virtualization, OpenShift Lightspeed AI integration for natural language operations assistance, AI development support with V100/L40s/H100 GPU worker nodes, expanded Microsoft and Oracle partnerships, and enhanced Watsonx.ai integration.

Key Features

  • Red Hat OpenShift: Kubernetes-based enterprise container platform
  • Watson AI: Industry-leading AI and machine learning platform with Watsonx integration
  • Hybrid Cloud: Comprehensive solutions integrating on-premises and cloud environments
  • Enterprise Security: Financial and government-grade security and compliance
  • IBM Z Integration: Seamless integration between mainframe and cloud systems

Latest 2025 Features

  • OpenShift Virtualization: Unified platform for VMs (virtual machines) and containers
  • OpenShift Lightspeed: AI-powered web console with natural language operation assistance
  • AI/GPU Enhancement: AI development with V100, L40s, and H100 worker nodes
  • Cloud Partnership Expansion: Enhanced Microsoft Azure and Oracle Cloud integration support
  • Watson AI Integration: Watsonx.ai integration with 170+ IBM Cloud services

Pros and Cons

Pros

  • Industry-leading Kubernetes platform with Red Hat OpenShift
  • Comprehensive enterprise AI and machine learning solutions with Watson AI
  • Mission-critical support backed by IBM's extensive enterprise experience
  • Consistent hybrid environment from mainframe (IBM Z) to cloud
  • Advanced security and compliance for financial and government institutions
  • Excellent integration capabilities and migration support for legacy systems
  • Industry-specific solutions and specialized expertise

Cons

  • More limited service offerings and ecosystem compared to AWS and Azure
  • Smaller developer community than mega cloud providers
  • Service availability limitations in some regions
  • Higher learning curve for non-IBM technologies
  • Fewer adoption cases among startups and small businesses
  • More restrictive third-party tool integrations compared to other clouds

Reference Pages

Code Examples

Basic Setup and Account Configuration

# Install IBM Cloud CLI
curl -fsSL https://clis.cloud.ibm.com/install/linux | sh

# Check CLI version
ibmcloud version

# Login to IBM Cloud account
ibmcloud login

# Set region
ibmcloud target -r us-south

# List resource groups
ibmcloud resource groups

# Show account information
ibmcloud account show

# Install plugins
ibmcloud plugin install container-service
ibmcloud plugin install container-registry

# Check available services
ibmcloud catalog service-offerings

# Create API key for programmatic access
ibmcloud iam api-key-create my-api-key -d "My API key for automation"

Compute Services (VMs, Containers)

from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_vpc import VpcV1
from ibm_container_service import IbmContainerServiceApiV1

# Configure IBM Cloud authentication
authenticator = IAMAuthenticator('your-ibm-cloud-api-key')

# Create VPC instance
vpc_service = VpcV1('2021-01-19', authenticator=authenticator)
vpc_service.set_service_url('https://us-south.iaas.cloud.ibm.com/v1')

# Create VPC (Virtual Private Cloud)
vpc_prototype = {
    'name': 'my-vpc',
    'resource_group': {'id': 'resource-group-id'}
}
vpc_response = vpc_service.create_vpc(vpc_prototype)
vpc_id = vpc_response.result['id']

# Create subnet
subnet_prototype = {
    'name': 'my-subnet',
    'vpc': {'id': vpc_id},
    'zone': {'name': 'us-south-1'},
    'ip_version': 'ipv4',
    'ipv4_cidr_block': '10.0.1.0/24'
}
subnet_response = vpc_service.create_subnet(subnet_prototype)

# Create virtual server instance (VSI)
instance_prototype = {
    'name': 'my-vsi-instance',
    'profile': {'name': 'bx2-2x8'},  # 2 vCPU, 8GB RAM
    'image': {'id': 'r006-14140f94-fcc4-11e9-96e7-a72723715315'},
    'zone': {'name': 'us-south-1'},
    'vpc': {'id': vpc_id},
    'primary_network_interface': {
        'subnet': {'id': subnet_response.result['id']}
    }
}
instance_response = vpc_service.create_instance(instance_prototype)

# Create Red Hat OpenShift cluster
container_service = IbmContainerServiceApiV1(authenticator=authenticator)
container_service.set_service_url('https://containers.cloud.ibm.com/global')

cluster_config = {
    'name': 'my-openshift-cluster',
    'location': 'dal10',
    'machine_type': 'b3c.4x16',
    'master_version': '4.14_openshift',  # 2025 latest OpenShift version
    'workers': [
        {
            'name': 'worker-1',
            'machine_type': 'b3c.4x16'
        }
    ]
}
cluster_response = container_service.create_cluster(**cluster_config)

Storage and Database Services

from ibm_cloud_databases import CloudDatabasesV5
from ibm_cos_sdk import S3

# Configure IBM Cloud Object Storage
cos_client = S3(
    aws_access_key_id='your-access-key',
    aws_secret_access_key='your-secret-key',
    endpoint_url='https://s3.us-south.cloud-object-storage.appdomain.cloud'
)

# Create bucket
bucket_name = 'my-ibm-cloud-bucket'
cos_client.create_bucket(Bucket=bucket_name)

# Upload file
with open('sample.txt', 'rb') as file:
    cos_client.upload_fileobj(file, bucket_name, 'sample.txt')

# Download file
cos_client.download_file(bucket_name, 'sample.txt', 'downloaded_sample.txt')

# Create IBM Cloud Databases for PostgreSQL
db_service = CloudDatabasesV5(authenticator=authenticator)
db_service.set_service_url('https://api.us-south.databases.cloud.ibm.com')

deployment_config = {
    'id': 'postgresql',
    'name': 'my-postgresql-db',
    'resource_group_id': 'resource-group-id',
    'location': 'us-south',
    'disk_encryption_key_crn': None,
    'backup_encryption_key_crn': None,
    'members': {
        'allocation_count': 2,
        'memory': {'allocation_mb': 1024},
        'disk': {'allocation_mb': 5120}
    }
}
db_response = db_service.create_deployment(deployment_config)

# Configure IBM Db2 (Warehouse edition)
db2_config = {
    'id': 'dashdb-for-transactions',
    'name': 'my-db2-warehouse',
    'resource_group_id': 'resource-group-id',
    'location': 'us-south',
    'members': {
        'allocation_count': 1,
        'memory': {'allocation_mb': 8192},
        'disk': {'allocation_mb': 20480}
    }
}
db2_response = db_service.create_deployment(db2_config)

Networking and Security

# Create security group
sg_prototype = {
    'name': 'my-security-group',
    'vpc': {'id': vpc_id},
    'rules': [
        {
            'direction': 'inbound',
            'protocol': 'tcp',
            'port_min': 22,
            'port_max': 22,
            'remote': {'cidr_block': '0.0.0.0/0'}
        },
        {
            'direction': 'inbound',
            'protocol': 'tcp',
            'port_min': 80,
            'port_max': 80,
            'remote': {'cidr_block': '0.0.0.0/0'}
        },
        {
            'direction': 'inbound',
            'protocol': 'tcp',
            'port_min': 443,
            'port_max': 443,
            'remote': {'cidr_block': '0.0.0.0/0'}
        }
    ]
}
sg_response = vpc_service.create_security_group(sg_prototype)

# Create load balancer
lb_prototype = {
    'name': 'my-load-balancer',
    'type': 'public',
    'subnets': [{'id': subnet_response.result['id']}],
    'resource_group': {'id': 'resource-group-id'}
}
lb_response = vpc_service.create_load_balancer(lb_prototype)

# Create VPN gateway
vpn_gateway_prototype = {
    'name': 'my-vpn-gateway',
    'subnet': {'id': subnet_response.result['id']},
    'resource_group': {'id': 'resource-group-id'}
}
vpn_response = vpc_service.create_vpn_gateway(vpn_gateway_prototype)

# IBM Cloud Internet Services (Cloudflare integration)
from ibm_cloud_internet_services import CisServicesV1

cis_service = CisServicesV1(authenticator=authenticator)
domain_config = {
    'name': 'example.com',
    'type': 'full'
}
domain_response = cis_service.create_zone('instance-id', **domain_config)

Serverless and Functions

from ibm_cloud_functions import CloudFunctionsV1

# Configure IBM Cloud Functions
functions_service = CloudFunctionsV1(authenticator=authenticator)
functions_service.set_service_url('https://us-south.functions.cloud.ibm.com/api/v1')

# Create namespace
namespace_config = {
    'name': 'my-functions-namespace',
    'resource_group_id': 'resource-group-id',
    'location': 'us-south'
}
namespace_response = functions_service.create_namespace(**namespace_config)

# Create action (function)
action_code = """
def main(params):
    name = params.get('name', 'World')
    return {'message': f'Hello, {name}!'}
"""

action_config = {
    'name': 'hello-action',
    'namespace': namespace_response['name'],
    'exec': {
        'kind': 'python:3.9',
        'code': action_code
    }
}
action_response = functions_service.create_action(**action_config)

# Create trigger
trigger_config = {
    'name': 'hello-trigger',
    'namespace': namespace_response['name']
}
trigger_response = functions_service.create_trigger(**trigger_config)

# Create rule (associate trigger with action)
rule_config = {
    'name': 'hello-rule',
    'namespace': namespace_response['name'],
    'trigger': f"{namespace_response['name']}/hello-trigger",
    'action': f"{namespace_response['name']}/hello-action"
}
rule_response = functions_service.create_rule(**rule_config)

# Execute function
invoke_config = {
    'name': 'hello-action',
    'namespace': namespace_response['name'],
    'params': {'name': 'IBM Cloud'}
}
result = functions_service.invoke_action(**invoke_config)

Monitoring and DevOps Integration

from ibm_logs import LogsV0
from ibm_sysdig import SysdigV1

# Configure IBM Cloud Logs
logs_service = LogsV0(authenticator=authenticator)
logs_service.set_service_url('https://api.us-south.logs.cloud.ibm.com')

# Create log application
log_app_config = {
    'name': 'my-app-logs',
    'subsystem_name': 'webapp'
}
log_app_response = logs_service.create_application(**log_app_config)

# Configure IBM Cloud Monitoring (Sysdig)
monitoring_service = SysdigV1(authenticator=authenticator)

# Create dashboard
dashboard_config = {
    'name': 'My Application Dashboard',
    'description': 'Dashboard for monitoring my application',
    'layout': {
        'type': 'grid'
    }
}
dashboard_response = monitoring_service.create_dashboard(**dashboard_config)

# Red Hat OpenShift DevOps integration
from kubernetes import client, config

# Connect to OpenShift cluster
config.load_kube_config()  # Requires OpenShift cluster kubeconfig

# Deployment configuration
deployment = client.V1Deployment(
    api_version="apps/v1",
    kind="Deployment",
    metadata=client.V1ObjectMeta(name="my-app"),
    spec=client.V1DeploymentSpec(
        replicas=3,
        selector=client.V1LabelSelector(
            match_labels={"app": "my-app"}
        ),
        template=client.V1PodTemplateSpec(
            metadata=client.V1ObjectMeta(
                labels={"app": "my-app"}
            ),
            spec=client.V1PodSpec(
                containers=[
                    client.V1Container(
                        name="my-app",
                        image="my-registry/my-app:latest",
                        ports=[client.V1ContainerPort(container_port=8080)]
                    )
                ]
            )
        )
    )
)

# Watson AI (Watsonx.ai) integration
from ibm_watsonx_ai import APIClient

# Configure Watsonx.ai
watsonx_credentials = {
    'url': 'https://us-south.ml.cloud.ibm.com',
    'apikey': 'your-api-key'
}
watsonx_client = APIClient(watsonx_credentials)

# AI model deployment configuration
model_config = {
    'name': 'my-ai-model',
    'type': 'online',
    'online': {
        'parameters': {
            'serving_name': 'my-model-serving'
        }
    }
}
deployment_response = watsonx_client.deployments.create(**model_config)