Containerize your .NET applicationsaround IBM i

It’s the application that adapts to the infrastructure, not the other way round. With NTi Data Provider, deploy containerized .NET applications that are portable and reproducible on any infrastructure.

  • Portable across Linux, ARM, Power…
  • Same behavior: dev, test, prod
  • Infinitely scalable, without touching IBM i
IBM Silver Partner logoMicrosoft Partner logo
The basics

What is a container?

Your application and everything it needs to run,
isolated from the host system.

Virtual machine

Your application
Full operating system
Hypervisor

Includes a full OS, often several gigabytes of overhead for a small application.

Container

Your application
Dependencies onlyRuntime, libraries, configuration
PortableReproducibleLightweight

Contains only your code and its dependencies, without a full operating system.

By embedding the runtime and dependencies with the application, the container removes the differences between environments.
What works in development works identically in test and in production.

.NET is already cloud ready

A platform designed to build,
deploy and run applications across different environments.

  • Cross-platform runtime

    .NET runs on Windows, Linux and macOS, as well as on x86, ARM and Power architectures. The same application runs in different environments, unchanged.

  • Self-contained application

    Everything the application needs is included in the image: .NET runtime, libraries, configuration. The host simply starts the container.

  • Official container images

    Microsoft provides maintained and supported base images, to run containerized .NET applications without worrying about the environment.

  • Standardized deployment

    A .NET application is built once, then deployed identically in development, test and production.

Dockerfile
1FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
2WORKDIR /src
3COPY . .
4RUN dotnet publish -c Release -o /app
5
6FROM mcr.microsoft.com/dotnet/runtime:8.0
7WORKDIR /app
8COPY --from=build /app .
9ENTRYPOINT ["dotnet", "MyApp.dll"]
From code to container

How it works

You build an image, then deploy it wherever you want.

  1. Step 1

    Develop

    A standard .NET application: API, service or console.

  2. Step 2

    Connect

    The NTi NuGet package opens access to DB2, RPG and CL.

  3. Step 3

    Package

    A standard Dockerfile, built on the official Microsoft images.

  4. Step 4

    Deploy

    Run the container on the host of your choice, with nothing to rebuild.

The same image runs on

  • Linuxx64
  • ARMarm64
  • IBM Powerppc64le
  • CloudAzure · AWS · GCP
  • Anywhere elseAny container host
Data access

A single IBM i access,
whatever the environment

NTi Data Provider is embedded in the .NET application, and therefore in the container.
Nothing to install on IBM i.

Container
.NET application
NTi Data ProviderEmbedded
IBM i
  • DB2 for i
  • RPG programs
  • CL commands
Benefits

Why containerize your .NET applications

  1. 01

    Decoupling and security

    Applications run outside IBM i, which is never exposed and keeps its native security mechanisms.

  2. 02

    Portability and reproducibility

    Same image, same runtime, same behavior across all environments.

  3. 03

    Scalability and lightness

    You duplicate lightweight containers on the .NET side, without putting load on IBM i.

  4. 04

    Standard tools

    Visual Studio, Git, CI/CD: less dependence on IBM i skills.

Scenarios

Use cases for .NET / IBM i
in a containerized environment

Containerized .NET API as an IBM i access layer

Context
Expose IBM i data and business logic without exposing the system to the Internet.
Implementation
A .NET API runs in a container and accesses DB2 for i, CL commands and RPG programs through NTi.
External clients.NET APIRuns in a containerIBM iDB2 · RPG · CLNot exposed to the Internet
  • IBM i remains the system of record
  • Application load is handled outside IBM i
  • IBM i is never directly exposed

Modern web front ends connected to IBM i

Context
Build modern interfaces while keeping IBM i as the back end.
Implementation
A containerized front end consumes a containerized .NET API, which accesses DB2 for i and other databases.
Web front endContainer.NET APIContainer · single .NET codebaseDB2 for iOther databases
  • Modern interfaces without rewriting RPG
  • Front end and back end evolve independently
  • Multi-database access from a single .NET codebase

High-performance Linux containers on IBM Power

Context
Make the most of IBM Power with demanding performance and latency requirements.
Implementation
Docker containers on a Linux on Power partition, connected to IBM i through the internal PowerVM network.
Linux on IBM Power.NET.NET.NETIBM iInternal PowerVM networkLow latency
  • Very low latency and high throughput
  • IBM i is not exposed to external networks
  • IBM Power infrastructure fully leveraged

CI/CD and reproducible environments

Context
Guarantee identical behavior across development, test and production.
Implementation
A single Docker image, deployed by standard .NET CI/CD pipelines. Configuration relies on environment variables.
Source codeGit repositoryCI/CD pipelineBuild and testsDocker imageBuilt only onceDevelopmentTestProductionThe same image, deployed everywhere
  • Identical behavior across all environments
  • Automated deployments, simple rollbacks
  • No impact on the IBM i configuration

Your .NET applications on every infrastructure

  • 30-day free trial
  • Ready in 5 minutes
  • No commitment