sp-runtime 46.0.0

Runtime Modules shared primitive types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# Using Containers

Using containers via **Podman** or **Docker** brings benefit, whether it is to build a container image or run a node
while keeping a minimum footprint on your local system.

This document mentions using `podman` or `docker`. Those are usually interchangeable and it is encouraged using
preferably **Podman**. If you have podman installed and want to use all the commands mentioned below, you can simply
create an alias with `alias docker=podman`.

There are a few options to build a node within a container and inject a binary inside an image.

## Parity built container image

Parity builds and publishes a container image that can be found as `docker.io/parity/polkadot-parachain`.

## Parity CI image

Parity maintains and uses internally a generic "CI" image that can be used as a base to build binaries: [Parity CI
container image](https://github.com/paritytech/dockerfiles/tree/main/ci-unified):

The command below allows building a Linux binary without having to even install Rust or any dependency locally:

```bash
export $(curl https://raw.githubusercontent.com/paritytech/polkadot-sdk/refs/heads/master/.github/env | tr -d '"')
docker run --rm -it \
    -w /polkadot-sdk \
    -v $(pwd):/polkadot-sdk \
    $IMAGE \
    cargo build --release --locked -p polkadot-parachain-bin --bin polkadot-parachain
sudo chown -R $(id -u):$(id -g) target/
```

To reproduce the clean CI environment locally you can use the following commands:

```bash
export $(curl https://raw.githubusercontent.com/paritytech/polkadot-sdk/refs/heads/master/.github/env | tr -d '"')
docker run -it --rm $IMAGE bash
root@e2ff8a3f347b:/builds# git clone https://github.com/paritytech/polkadot-sdk.git && cd polkadot-sdk
root@e2ff8a3f347b:/builds# <your cargo command goes here>
```

## Injected image

Injecting a binary inside a base image is the quickest option to get a working container image. This only works if you
were able to build a Linux binary, either locally, or using a container as described above.

After building a Linux binary (`polkadot-parachain`) with cargo or with Parity CI image as documented above, the
following command allows producing a new container image where the compiled binary is injected:

```bash
ARTIFACTS_FOLDER=./target/release /docker/scripts/build-injected.sh
```

## Container build

Alternatively, you can build an image with a builder pattern. This options takes a while but offers a simple method for
anyone to get a working container image without requiring any of the Rust toolchain installed locally.

```bash
docker build \
	--tag $OWNER/$IMAGE_NAME \
 --file ./docker/dockerfiles/polkadot-parachain/polkadot-parachain_builder.Dockerfile .
```

You may then run your new container:

```bash
docker run --rm -it \
	$OWNER/$IMAGE_NAME \
		--collator --tmp \
		--execution wasm \
		--chain /specs/asset-hub-westend.json
```