Skip to content

Getting Started

There are two ways in. Which one you want depends on whether you are writing an xApp or working on the SDK itself.

The short way: the CLI

For writing an xApp, install the CLI and generate a project. It needs no airpuls-ric checkout, no CMake, and no C toolchain:

pip install airpuls-sdk-cli
airpuls-sdk xapp new my-xapp
cd my-xapp && airpuls-sdk xapp run

That gives you a validating project with a working KPM subscription, a Dockerfile, a test suite, and the deployment launcher. The full command surface is on The airpuls-sdk CLI; the rest of this page is the manual path.

The long way: build from a checkout

Build this when you are changing the SDK, writing a Go or C xApp, or building the base image yourself. The SDK builds on Linux against the same C libraries as the RIC: build the C tree first (it produces the static archives every binding links), then set up your language.

Linux only

The C client uses eventfd, so the SDK builds and runs on Linux. Develop on a Linux build host (or inside the SDK Docker image); macOS can build the codec/registry tests but not the client.

Build the C libraries first

# From the repo root — build the client and the per-SM archives.
mkdir build && cd build
cmake ..
make -j$(nproc) ric_client e2sm_kpm e2sm_rc e2sm_ccc e2sm_llc e2sm_air airpuls_common airpuls_asn

AIRPULS_RIC_BUILD_DIR defaults to <repo>/build/src and is the path the bindings look for these archives under.

Python

The Python binding is CFFI over the C client. It needs a virtualenv and the C build present:

python3 -m venv .venv
source .venv/bin/activate
export AIRPULS_RIC_BUILD_DIR=$(pwd)/build/src
export AIRPULS_RIC_SRC_DIR=$(pwd)/src
pip install -e src/sdk/lang_bindings/python/

Smoke-test the import:

from airpuls_ric_sdk.xapp import BaseXApp
from airpuls_ric_sdk import kpm_plugin_get, KPM_RAN_FUNC_ID
print(KPM_RAN_FUNC_ID)   # 2

Or use the published wheel

A binary wheel (manylinux, x86-64) may be published to your package index for deployments that don't build from source. When available, pip install airpuls-ric-sdk pulls the prebuilt binding with GLib vendored in.

Go

The Go binding is cgo over the C client. xApps live under xapps/<name>/go/ as their own module with a replace directive pointing at the in-tree bindings at src/sdk/lang_bindings/go/.

# Build the C archives (as above), then the bindings package:
export AIRPULS_RIC_BUILD_DIR=$(pwd)/build/src
make -C src/sdk/lang_bindings/go build
make -C src/sdk/lang_bindings/go test

The binding's Makefile exports CGO_CFLAGS / CGO_LDFLAGS automatically from AIRPULS_RIC_BUILD_DIR. Go xApps then build with their own make -C xapps/<name>/go build.

C

Link your xApp against the client and the SM archives you use:

target_link_libraries(my_xapp PRIVATE
    ric_client e2sm_kpm airpuls_common)

Include ric-client.h, xapp-config.h, and the SM header(s) you need (e.g. e2sm-kpm.h).

Fastest path: the SDK Docker image

You don't have to set any of this up locally. The SDK base image ships libairpuls_common.a, every libe2sm_<sm>.a, libric_client.a, the public headers, and the Python binding preinstalled:

docker pull airpuls/airpuls-xapp-sdk:latest

Every reference xApp builds FROM it — see Packaging, which also covers building the image from a checkout and the tags to pin.

Next steps