For some, what I’m about to describe might seem obvious. However, in my experience, many people still don’t fully understand how different technologies interact with each other and what their specific applications are. I encounter opinions that containerization is an unnecessary addition, and that the entire infrastructure can be built on “ordinary” x86 servers. Others, fascinated by the capabilities of the IBM Power platform (PowerVM), would like to base everything on it, disregarding the specifics of individual applications and, let’s face it, the costs. And yet, an inefficiently designed and expensive infrastructure means fewer resources for development, innovation – and, ultimately, for our salaries.
Before you read on: I want to point out that I am not an IT architect, but I have been working with infrastructure for a long time, and this topic interests me greatly. The following text is my perspective on the issues of combining IBM Power, x86, and containerization technologies, based on what I see, read, and discuss with other specialists. I could be wrong – if you notice any errors or have a different opinion, let me know in the comments!
Let’s try to look at IT infrastructure like a bustling city. We have powerful trucks (IBM Power), agile passenger cars (x86), and lightning-fast couriers on bicycles (containers). Each of these vehicles has its own unique role and route. There is no single, universal solution. You wouldn’t send a courier on a bicycle with a load that requires a truck, nor would you use a truck to deliver a small package in a crowded city center.
Choosing the right architecture is an important decision that affects the performance, reliability, scalability, and flexibility of your systems. Individual technologies differ in capabilities and characteristics. Some are designed to handle huge workloads and critical applications, while others are better suited to dynamically changing environments where speed and agility are important. Poorly planned “traffic” in the IT infrastructure means traffic jams (delays), accidents (failures), and untapped potential. So how do you organize this “traffic” so that everything works smoothly, safely, and efficiently, and data arrives on time where it should? The point is to use the right “vehicle” for the right task – and to understand how these “vehicles” work together.
IBM Power – Trucks (large loads, high reliability, specialized routes)
These are powerful tractor-trailers, transporting large and critical loads (data and applications) on long and demanding routes. These are not vehicles for everyday, small shipments, but for tasks where reliability and performance are an absolute priority. Think of them as transporting valuable and sensitive goods that must arrive on time and in perfect condition.
What systems are they for?
- Large, monolithic databases:
- Oracle Database: IBM Power is often a certified and optimized platform for large Oracle deployments, especially those requiring extreme performance and availability.
- SAP HANA: Similar to Oracle, IBM Power is a popular choice for SAP HANA, due to its high performance and vertical scalability.
- IBM Db2: IBM’s own database, naturally optimized for the Power platform.
- ERP (Enterprise Resource Planning) systems:
- SAP: Key SAP systems (e.g., S/4HANA) often run on IBM Power, due to performance and reliability requirements.
- Other ERP Systems: Systems that require very high performance and reliability.
- Critical transaction systems:
- Banking: Payment processing systems, online banking systems, account management systems.
- Insurance: Policy management systems, billing systems.
- Telecommunications: Billing systems, network management systems.
- **Retail:**Large data warehouses.
- Other Applications: Legacy, monolithic applications requiring high reliability.
- AIX, IBM i, Linux: Operating systems used by the platform.
Advantages of IBM Power:
- High performance: The Power architecture is optimized for processing large workloads, offering high throughput and low latency.
- Unmatched reliability (RAS): Reliability, Availability, Serviceability. This is a key feature. Power systems are designed to minimize downtime. They have hardware redundancy (redundant power supplies, RAID controllers, hot-swap components) and advanced error detection and correction mechanisms.
- Vertical scalability: The ability to expand an existing system (adding processors, memory, disks) without having to replace the entire machine. This is important for systems that need to grow with the company’s development.
- Security: Advanced security features at the hardware and software level.
- Virtualization (PowerVM): Very efficient and mature virtualization technology, allowing you to run multiple virtual machines on a single physical server. PowerVM offers advanced features such as Live Partition Mobility (migrating virtual machines without interrupting work).
- **Long life cycle:**Long-term manufacturer support of the hardware platform.
- Consolidation: The ability to run many different environments (e.g., AIX, Linux, IBM i) on one machine.
Disadvantages of IBM Power:
- Higher cost: Both the cost of purchasing the hardware and the cost of maintenance (power, cooling, service) are usually higher than for x86 servers.
- Less flexibility: Vertical scalability has its limitations. At some point, you need to add another server.
- Smaller software selection: Although the situation is improving, the choice of software (especially open source) is smaller than for x86. Many applications must be specially compiled and optimized for Power.
- Smaller pool of specialists: It is harder to find specialists in IBM Power than in x86.
- Less “agility”: Making changes (e.g., adding new features) in large, monolithic systems running on Power is usually more time-consuming and complicated than with microservices running in containers.
- Specialization: Not suitable for every type of workload, this is a platform designed for specific tasks.
IBM Power is a specialized compute platform, designed for critical applications where reliability, performance, and security are paramount. It is not a solution for everyone, but in appropriate scenarios (large databases, ERP systems, transaction systems) it can be irreplaceable. It’s worth remembering that Power is not only hardware, but also a mature ecosystem of software (AIX, IBM i, PowerVM) and services.
x86 – Passenger Cars and Vans (versatility, flexibility, daily commutes)
x86 are agile and versatile passenger cars, ideal for everyday commutes and various tasks in the IT infrastructure. It is the dominant architecture in the server market, offering flexibility, horizontal scalability, and a wide selection of hardware and software. Think of them as vehicles that are good enough for most applications, while being readily available and relatively inexpensive.
What systems are they for?
- Web applications:
- Online banking (frontend): Portals and mobile applications for bank customers, enabling access to accounts, making transfers, submitting applications, etc.
- Customer service systems (telco): Portals and applications for customers of telecommunications companies, enabling account management, checking invoices, activating services, reporting problems, etc.
- Transaction platforms (brokers, exchanges): Systems enabling customers to make transactions on financial markets (e.g., buying stocks, bonds, currencies).
- CRM Systems (Customer Relationship Management) (Front End): Interfaces for employees to handle clients.
- Databases:
- MySQL, PostgreSQL, Microsoft SQL Server: Popular relational databases, often used in web and business applications. Most deployments of these databases run on x86.
- NoSQL: MongoDB, Cassandra, Redis – NoSQL databases, designed to work in clusters (on multiple x86 servers), providing scalability and redundancy.
- Graph databases: Neo4j, Amazon Neptune.
- Analytical systems: Data processing and analysis (often in conjunction with the cloud).
- File and print servers.
- Mail systems
- Most business applications that do not have extreme performance and reliability requirements (as with IBM Power).
- VDI (Virtual Desktop Infrastructure) infrastructure: Delivering virtual desktops to users.
Advantages of x86: - Versatility: Huge selection of hardware (servers from different manufacturers, different configurations) and software (operating systems, applications).
- Horizontal scalability: Ease of adding more servers (physical or virtual) as needed.
- Flexibility: Ability to quickly adapt to changing business needs.
- Cost: Usually lower cost of purchase and maintenance.
- Wide availability of specialists: Easy to find specialists in x86 and VMware/other virtualization technologies.
- Large community: Easy access to knowledge and support.
Disadvantages of x86:
- Lower reliability (compared to IBM Power): Redundancy and high availability are usually implemented at the application level or through hypervisor features (e.g., VMware HA). There is no hardware redundancy at the same level as in IBM Power.
- Lower performance: In some very demanding applications (e.g., huge databases, transaction systems with extreme performance) IBM Power may offer better performance.
- Management complexity (in large environments): Managing a very large number of virtual machines and physical servers can be complicated.
- VMware license costs: VMware vSphere is commercial software, and license costs (especially for advanced features) can be significant. (There are open source alternatives, e.g., KVM, but they may require more technical knowledge).
- Virtualization overhead: Virtualization introduces some performance overhead.
x86 is the foundation of modern IT infrastructure. It is a versatile and flexible solution that works for most applications. It offers a good performance-to-price ratio and a wide selection of hardware and software. It is not an ideal solution for all applications (e.g., where absolute reliability is required, IBM Power is a better choice).
Containers (Kubernetes/OpenShift) – Couriers on Bicycles (agility, speed, small packages, and a revolution in IT)
This is a relatively new, but revolutionary approach to deploying and managing applications that is changing the way we build and run software. Imagine a fleet of agile couriers on bicycles, delivering small packages (applications and their dependencies) quickly and efficiently, even in the most congested city.
- Containers (Docker, Podman): These are lightweight, portable “boxes” that contain an application and everything it needs to run (libraries, configuration, runtime environment). The container is isolated from the rest of the system, which ensures consistency of operation and makes it easy to move applications between different environments (developer’s laptop, test server, production, cloud).
- Kubernetes and OpenShift: These are platforms for managing this fleet of containers. They automate the deployment, scaling, monitoring, and management of containers. Think of them as an advanced logistics system that ensures that each courier (container) arrives on time, and if necessary, automatically sends more couriers (scaling) or replaces those that have failed (self-healing).
- Kubernetes (K8s): This is an open-source platform that has become the de facto standard in containerization. It provides basic container management functions.
- OpenShift: This is a platform built on Kubernetes, but extended with additional features to make it easier for developers and administrators to work. It offers, among other things:
- Simplified user interface.
- Integrated CI/CD (Continuous Integration/Continuous Delivery) tools.
- Greater emphasis on security.
- Red Hat support.
What systems are they for?
- Modern web applications (frontend):
- Online banking (mobile and web applications): Interfaces for customers – not the entire online banking systems, but the parts responsible for interacting with the user.
- Customer service systems (telco): Applications for managing accounts, checking invoices, activating services.
- Transaction platforms (parts): Some modules of transaction platforms.
- DevOps tools:
- CI/CD (Continuous Integration/Continuous Delivery).
- Monitoring.
- Logging.
- Backend microservices:
- Authentication and authorization services.
- Notification services.
- Payment processing services (parts).
- Report generation services.
- API services.
- Integration services.
- Caching services.
- AI/ML Systems:
- Serving machine learning models.
- Chatbots and virtual assistants.
Advantages of Containerization (Kubernetes/OpenShift):
- Agility: Instant deployment of new application versions (minutes instead of hours or days). This enables faster response to market needs and more frequent innovation.
- Speed of Response: Speed of starting, replicating, and shutting down containers.
- Scalability: Easy and fast scaling of applications up or down depending on the load. Kubernetes/OpenShift can automatically add or remove containers.
- Efficiency: Containers are much lighter than virtual machines – they consume fewer resources (processor, memory, disk). This allows for better utilization of infrastructure and lower costs.
- Portability: Containers work the same on different platforms (developer’s laptop, test server, production, different clouds). This simplifies the deployment process and eliminates the “it works on my machine” problem.
- Microservices: Containers are ideal for microservice architecture, which facilitates the development, testing, deployment, and maintenance of complex applications.
- Statelessness and Flexibility: Ability to quickly start and destroy containers without losing data (data is stored outside the container). This provides high availability and fault tolerance.
- Automation: Automatic scaling, deployment, and disaster recovery.
- Standardization: A unified way to package, deploy, and manage applications.
Disadvantages of Containerization (Kubernetes/OpenShift):
- Complexity: Deploying and managing containerization platforms (Kubernetes, OpenShift) is more complicated than the traditional approach. It requires new skills and tools.
- Security: Containerization requires a careful approach to security. You need to take care of the security of the containers themselves (e.g., use trusted images) as well as the Kubernetes/OpenShift platform. You need to remember about regular updates and monitoring for threats.
- Not for all applications: Containerization is not an ideal solution for all types of applications. Large, monolithic applications, especially those tightly integrated with hardware or the operating system, can be difficult or impossible to containerize.
- Data Management: Persistent data storage in containers requires careful planning and management.
- Monitoring: Effective monitoring of a distributed, dynamic container environment is a challenge.
Where do containers run?
- Usually on virtualized x86 servers (locally or in the cloud).
- They can also run on IBM Power
- Less often – directly on physical hardware (“bare metal”).
Containerization, Kubernetes, and OpenShift are key technologies in modern IT infrastructure, offering unprecedented agility, scalability, and efficiency. It is not an ideal solution for all applications, but in many cases (especially for new applications and microservices) they are the best choice, revolutionizing the way we create and run software, particularly in dynamic environments.
Conclusions
As you can see, modern IT infrastructure is not a monolith, but a complex ecosystem where different technologies work together to provide optimal performance, reliability, scalability, and flexibility. There is no single, universal solution – the choice of the right technology depends on the specific needs and requirements of individual applications and systems.
A common model is a hybrid architecture, where:
- IBM Power (Trucks): Handles critical systems and large, monolithic databases (e.g., Oracle, SAP HANA, Db2), where reliability and performance are an absolute priority. Here, data is persistently stored and intensively processed.
- x86 (Passenger Cars and Vans – with VMware or other virtualization): Is the foundation for most business applications, including web applications (often frontends for systems running on Power), smaller and medium-sized databases (e.g., MySQL, PostgreSQL, SQL Server), as well as NoSQL and graph databases.
- Containers (Kubernetes/OpenShift – Couriers on Bicycles): Provide agility and scalability for modern applications, microservices, and DevOps tools. By design and in an ideal scenario, containers are stateless – they do not store data persistently inside themselves. All the application logic is in the container, but the data (if needed) is retrieved from external sources (e.g., databases on Power or x86, file systems, object storage). This statelessness allows for the instant creation, destruction, and scaling of containers without data loss and without consequences. This is the ideal solution for dynamic environments where new application versions are frequently deployed and where the load can change rapidly. And here we come to the operation desired by many – shutting down unused environments (e.g., test environments at night), which brings significant savings (energy, cloud resources). In the case of traditional virtual machines (x86) or LPARs (Power), such “shutting down” is much more difficult or impossible due to their statefulness and association with data.
In such a model, data flows between different platforms.
For example:
- A user uses a web application (frontend) running on a container (Kubernetes/OpenShift).
- The container communicates with backend services (also in containers) or directly with a database on x86 (e.g., PostgreSQL).
- Some operations (e.g., processing a financial transaction) may require communication with a database on IBM Power (e.g., Oracle, Db2).
Automation – the key to effective management
Managing such a complex and diverse infrastructure would be a huge challenge without automation. Tools such as:
- Ansible: Automating server configuration, application deployment, network management.
- Chef: Similar to Ansible – automating infrastructure configuration and management.
- Terraform: Defining and creating infrastructure as code (IaC). Allows for the automatic creation and management of resources in the cloud (e.g., virtual machines, networks, databases) and locally (e.g., VMware virtual machines).
- Puppet: Like Ansible and Chef, it is used for configuration automation.
Enable management of the entire infrastructure (IBM Power, x86, containers) in a consistent and automated way, from one place, using code. This reduces the risk of human error, speeds up the deployment of changes, and makes it easier to maintain the infrastructure.
Summary
Modern IT infrastructure is a dynamic ecosystem in which various technologies – IBM Power, x86, containers – work together to create a cohesive and efficient whole. The key to success is understanding the strengths and weaknesses of each, combining them skillfully, and automating management. Only in this way can we build an infrastructure that not only meets the requirements but is also ready for the challenges of the future, without generating unnecessary costs, which – as I mentioned at the beginning – ultimately affect us all. It’s about finding a balance between performance, reliability, scalability, flexibility, and cost, and that requires a deep understanding of the full spectrum of available technologies