Computing Provider

A computing provider is an individual or organization that participates in the decentralized computing network by offering computational resources such as processing power (CPU and GPU), memory, storage, and bandwidth. Their primary role is to execute tasks assigned by Orchestrator on the Swan chain.

Table of Content

Prerequisites
Install the Kubernetes
Install and config the Nginx
Install the Hardware resource-exporter
Install the Redis service
Build and config the Computing Provider
Install AI Inference Dependency(Optional)
Config and Receive UBI Tasks(optional)
Start the Computing Provider
CLI of Computing Provider

Prerequisites

Before you install the Computing Provider, you need to know there are some resources required:

Possess a public IP
Have a domain name (*.example.com)
Have an SSL certificate
Go version must 1.19+, you can refer here:

wget -c https://golang.org/dl/go1.19.7.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local

echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bashrc && source ~/.bashrc

Install the Kubernetes

The Kubernetes version should be v1.24.0+

Install Container Runtime Environment

If you plan to run a Kubernetes cluster, you need to install a container runtime into each node in the cluster so that Pods can run there, refer to here. And you just need to choose one option to install the Container Runtime Environment

Option 1: Install the `Docker` and `cri-dockerd` （Recommended）

To install the Docker Container Runtime and the cri-dockerd, follow the steps below:

Install the Docker:
- Please refer to the official documentation from here.
Install cri-dockerd:
- cri-dockerd is a CRI (Container Runtime Interface) implementation for Docker. You can install it refer to here.

Option 2: Install the `Containerd`

Containerd is an industry-standard container runtime that can be used as an alternative to Docker. To install containerd on your system, follow the instructions on getting started with containerd.

Optional-Setup a docker registry server

If you are using the docker and you have only one node, the step can be skipped.

If you have deployed a Kubernetes cluster with multiple nodes, it is recommended to set up a private Docker Registry to allow other nodes to quickly pull images within the intranet.

Create a directory /docker_repo on your docker server. It will be mounted on the registry container as persistent storage for our docker registry.

sudo mkdir /docker_repo
sudo chmod -R 777 /docker_repo

Launch the docker registry container:

sudo docker run --detach \
  --restart=always \
  --name registry \
  --volume /docker_repo:/docker_repo \
  --env REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY=/docker_repo \
  --publish 5000:5000 \
  registry:2

Add the registry server to the node
- If you have installed the Docker and cri-dockerd(Option 1), you can update every node's configuration:
```
 sudo vi /etc/docker/daemon.json
```
```
 ## Add the following config
 "insecure-registries": ["<Your_registry_server_IP>:5000"]
```
Then restart the docker service
```
 sudo systemctl restart docker
```
- If you have installed the containerd(Option 2), you can update every node's configuration:

[plugins."io.containerd.grpc.v1.cri".registry]
  [plugins."io.containerd.grpc.v1.cri".registry.mirrors]
    [plugins."io.containerd.grpc.v1.cri".registry.mirrors."<Your_registry_server_IP>:5000"]
      endpoint = ["http://<Your_registry_server_IP>:5000"]

[plugins."io.containerd.grpc.v1.cri".registry.configs]
  [plugins."io.containerd.grpc.v1.cri".registry.configs."<Your_registry_server_IP>:5000".tls]
      insecure_skip_verify = true

Then restart containerd service

sudo systemctl restart containerd

<Your_registry_server_IP>: the intranet IP address of your registry server.

Finally, you can check the installation by the command:

docker system info

Create a Kubernetes Cluster

To create a Kubernetes cluster, you can use a container management tool like kubeadm. The below steps can be followed:

Install the Network Plugin

Calico is an open-source networking and network security solution for containers, virtual machines, and native host-based workloads. Calico supports a broad range of platforms including Kubernetes, OpenShift, Mirantis Kubernetes Engine (MKE), OpenStack, and bare metal services.

To install Calico, you can follow the below steps, more information can be found here.

step 1: Install the Tigera Calico operator and custom resource definitions

kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.1/manifests/tigera-operator.yaml

step 2: Install Calico by creating the necessary custom resource

kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.1/manifests/custom-resources.yaml

step 3: Confirm that all of the pods are running with the following command

watch kubectl get pods -n calico-system

step 4: Remove the taints on the control plane so that you can schedule pods on it.

kubectl taint nodes --all node-role.kubernetes.io/control-plane-
kubectl taint nodes --all node-role.kubernetes.io/master-

If you have installed it correctly, you can see the result shown in the figure by the command kubectl get po -A

Note:

If you are a single-host Kubernetes cluster, remember to remove the taint mark, otherwise, the task can not be scheduled to it.

kubectl taint node ${nodeName}  node-role.kubernetes.io/control-plane:NoSchedule-

Install the NVIDIA Plugin

If your computing provider wants to provide a GPU resource, the NVIDIA Plugin should be installed, please follow the steps:

Install NVIDIA Driver.

Recommend NVIDIA Linux drivers version should be 470.xx+

Install NVIDIA Device Plugin for Kubernetes.

If you have installed it correctly, you can see the result shown in the figure by the command kubectl get po -n kube-system

Install the Ingress-nginx Controller

The ingress-nginx is an ingress controller for Kubernetes using NGINX as a reverse proxy and load balancer. You can run the following command to install it:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.7.1/deploy/static/provider/cloud/deploy.yaml

If you have installed it correctly, you can see the result shown in the figure by the command:

Run kubectl get po -n ingress-nginx

Run kubectl get svc -n ingress-nginx

Install and config the Nginx

Install Nginx service to the Server

sudo apt update
sudo apt install nginx

Add a configuration for your Domain name Assume your domain name is *.example.com

vi /etc/nginx/conf.d/example.conf

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
        listen 80;
        listen [::]:80;
        server_name *.example.com;                                           # need to your domain
        return 301 https://$host$request_uri;
        #client_max_body_size 1G;
}
server {
        listen 443 ssl;
        listen [::]:443 ssl;
        ssl_certificate  /etc/letsencrypt/live/example.com/fullchain.pem;     # need to config SSL certificate
        ssl_certificate_key  /etc/letsencrypt/live/example.com/privkey.pem;   # need to config SSL certificate

        server_name *.example.com;                                            # need to config your domain
        location / {
          proxy_pass http://127.0.0.1:<port>;  	# Need to configure the Intranet port corresponding to ingress-nginx-controller service port 80 
          proxy_set_header Host $http_host;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection $connection_upgrade;
       }
}

Note:
- server_name: a generic domain name
- ssl_certificate and ssl_certificate_key: certificate for https.
- proxy_pass: The port should be the Intranet port corresponding to ingress-nginx-controller service port 80
Reload the Nginx config
```
sudo nginx -s reload
```
Map your "catch-all (wildcard) subdomain(*.example.com)" to a public IP address

Install Hardware resource-exporter

The resource-exporter plugin is developed to collect the node resource constantly, computing provider will report the resource to the Lagrange Auction Engine to match the space requirement. To get the computing task, every node in the cluster must install the plugin. You just need to run the following command:

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: DaemonSet
metadata:
  namespace: kube-system
  name: resource-exporter-ds
  labels:
    app: resource-exporter
spec:
  selector:
    matchLabels:
      app: resource-exporter
  template:
    metadata:
      labels:
        app: resource-exporter
    spec:
      containers:
      - name: resource-exporter
        image: filswan/resource-exporter:v11.2.5
        imagePullPolicy: IfNotPresent
EOF

If you have installed it correctly, you can see the result shown in the figure by the command: kubectl get po -n kube-system

Install Redis service

Install the redis-server

sudo apt update
sudo apt install redis-server

Run Redis service:

systemctl start redis-server.service

Build and config the Computing Provider

Build the Computing Provider

Firstly, clone the code to your local:

git clone https://github.com/lagrangedao/go-computing-provider.git
cd go-computing-provider
git checkout v0.4.3

Then build the Computing provider follow the below steps:

make clean && make
make install

Update Configuration The computing provider's configuration sample locate in ./go-computing-provider/config.toml.sample

cp config.toml.sample config.toml

Edit the necessary configuration files according to your deployment requirements. These files may include settings for the computing-provider components, container runtime, Kubernetes, and other services.

[API]
Port = 8085                                     # The port number that the web server listens on
MultiAddress = "/ip4/<public_ip>/tcp/<port>"    # The multiAddress for libp2p
Domain = ""                                     # The domain name
NodeName = ""                                   # The computing-provider node name

RedisUrl = "redis://127.0.0.1:6379"           # The redis server address
RedisPassword = ""                            # The redis server access password

[UBI]
UbiTask = true                                 # Accept the UBI task (Default: true)
UbiEnginePk = "0xB5aeb540B4895cd024c1625E146684940A849ED9"  # UBI Engine's public key, CP only accept the task from this UBI engine 
UbiUrl ="https://ubi-task.swanchain.io/v1"     # UBI Engine's API address

[LOG]
CrtFile = "/YOUR_DOMAIN_NAME_CRT_PATH/server.crt"   # Your domain name SSL .crt file path
KeyFile = "/YOUR_DOMAIN_NAME_KEY_PATH/server.key"   # Your domain name SSL .key file path

[HUB]
ServerUrl = "https://orchestrator-api.swanchain.io"     # The Orchestrator's API address
AccessToken = ""                                    # The Orchestrator's access token, Acquired from "https://orchestrator.swanchain.io" 
WalletAddress = ""                                  # The cp‘s wallet address
BalanceThreshold= 1                                # The cp’s collateral balance threshold

[MCS]
ApiKey = ""                                   # Acquired from "https://www.multichain.storage" -> setting -> Create API Key
BucketName = ""                               # Acquired from "https://www.multichain.storage" -> bucket -> Add Bucket
Network = "polygon.mainnet"                   # polygon.mainnet for mainnet, polygon.mumbai for testnet
FileCachePath = "/tmp"                        # Cache directory of job data

[Registry]
ServerAddress = ""                            # The docker container image registry address, if only a single node, you can ignore
UserName = ""                                 # The login username, if only a single node, you can ignore
Password = ""                                 # The login password, if only a single node, you can ignore

[RPC]
SWAN_TESTNET ="https://saturn-rpc.swanchain.io"  # Swan testnet RPC
SWAN_MAINNET= ""								   # Swan mainnet RPC

[CONTRACT]
SWAN_CONTRACT="0x91B25A65b295F0405552A4bbB77879ab5e38166c"   # Swan token's contract address
SWAN_COLLATERAL_CONTRACT="0xB8D9744b46C1ABbd02D62a7eebF193d83965ba39"   # Swan's collateral address

Install AI Inference Dependency

It is necessary for Computing Provider to deploy the AI inference endpoint. But if you do not want to support the feature, you can skip it.

export CP_PATH=xxx
./install.sh

Config and Receive UBI Tasks

Step 1: Prerequisites: Perform Filecoin Commit2 (fil-c2) UBI tasks.

Download the tool for Filecoin Commit2 task parameters:

wget https://github.com/swanchain/ubi-benchmark/releases/download/v0.0.1/lotus-shed

Download parameters (specify path with FIL_PROOFS_PARAMETER_CACHE variable):

export FIL_PROOFS_PARAMETER_CACHE=/var/tmp/filecoin-proof-parameters
lotus-shed fetch-params --proving-params 512MiB # 512MiB represent sector size
lotus-shed fetch-params --proving-params 32GiB # 32GiB represent sector size

Configure environment variables in fil-c2.env under CP repo ($CP_PATH):

FIL_PROOFS_PARAMETER_CACHE="/var/tmp/filecoin-proof-parameters"
RUST_GPU_TOOLS_CUSTOM_GPU="GeForce RTX 3080:8704"

Adjust the value of RUST_GPU_TOOLS_CUSTOM_GPU based on the GPU used by the CP's Kubernetes cluster for fil-c2 tasks.
For more device choices, please refer to this page:https://github.com/filecoin-project/bellperson

Step 2: Enable UBI tasks in CP's `config.toml`:

[UBI]
UbiTask = true

Step 3: Initialize a Wallet and Deposit Swan-ETH

Generate a new wallet address:

computing-provider wallet new

Example output:

0x7791f48931DB81668854921fA70bFf0eB85B8211

Deposit Swan-ETH to the generated wallet address as a gas fee:

computing-provider wallet send --from 0xFbc1d38a2127D81BFe3EA347bec7310a1cfa2373 0x7791f48931DB81668854921fA70bFf0eB85B8211 0.001

Example output:

0xa255d9046eff7c7c7ef6f4b55efcf97b62c79aeece748ab2188de21da620f29b

Note: Follow this guide to claim Swan-ETH and bridge it to Swan Saturn Chain.

Step 4: Initialization

Deploy a contract with CP's basic info:

computing-provider init --ownerAddress 0xFbc1d38a2127D81BFe3EA347bec7310a1cfa2373

Output:

Contract deployed! Address: 0x3091c9647Ea5248079273B52C3707c958a3f2658
Transaction hash: 0xb8fd9cc9bfac2b2890230b4f14999b9d449e050339b252273379ab11fac15926
The height of the block: 44900354

Step 5: Account Management

Use computing-provider account subcommands to update CP details:

computing-provider account -h
NAME:
   computing-provider account - Manage account info of CP

USAGE:
   computing-provider account command [command options] [arguments...]

COMMANDS:
   changeMultiAddress        Update MultiAddress of CP
   changeOwnerAddress        Update OwnerAddress of CP
   changeBeneficiaryAddress  Update BeneficiaryAddress of CP
   changeUbiFlag             Update UbiFlag of CP
   help, h                   Shows a list of commands or help for one command

OPTIONS:
   --help, -h  show help

Step 6: Check the Status of UBI-Task

To check the UBI task list, use the following command:

computing-provider ubi-task list

Example output:

TASK ID TASK TYPE       ZK TYPE         TRANSACTION HASH                                                        STATUS  REWARD  CREATE TIME         
2       CPU             fil-c2-512M     0xb06b3a8c2b2b96b564777a3866e27ce7c61631f77e5de3196e93eb916b0d2575      success 2.0     2024-01-20 03:30:30
33      CPU             fil-c2-512M     0x7567435e83a4a019a6356da8cf33e64a071f2d3355fce5289b9c17cf0144f282      success 2.0     2024-01-18 15:58:21
13      CPU             fil-c2-512M     0x7b3081314891aad3788c84935c67f9be0a8acc6b4fc77c5aa6fdfda728877fde      success 2.0     2024-01-20 04:27:40
238     CPU             fil-c2-512M     0xb8eb1f7b3cfc8210fa5546adc528f230241110e5cc9b4900725a9da28895aad9      success 2.0     2024-01-18 17:08:21

Start the Computing Provider

You can run computing-provider using the following command

export CP_PATH=xxx
nohup computing-provider run >> cp.log 2>&1 &

CLI of Computing Provider

Check the current list of tasks running on CP, display detailed information for tasks using -v

computing-provider task list

Retrieve detailed information for a specific task using space_uuid

computing-provider task get [space_uuid]

Delete task by space_uuid

computing-provider task delete [space_uuid]

Getting Help

For usage questions or issues reach out to the Swan team either in the Discord channel or open a new issue here on GitHub.

License

Apache

Name		Name	Last commit message	Last commit date
Latest commit History 644 Commits
account		account
build		build
cmd/computing-provider		cmd/computing-provider
conf		conf
constants		constants
internal		internal
test		test
util		util
wallet		wallet
.gitignore		.gitignore
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
README_CN.md		README_CN.md
config.toml.sample		config.toml.sample
fil-c2.env		fil-c2.env
go.mod		go.mod
go.sum		go.sum
install.sh		install.sh
resource_policy.json		resource_policy.json

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Computing Provider

Table of Content

Prerequisites

Install the Kubernetes

Install Container Runtime Environment

Option 1: Install the `Docker` and `cri-dockerd` （Recommended）

Option 2: Install the `Containerd`

Optional-Setup a docker registry server

Create a Kubernetes Cluster

Install the Network Plugin

Install the NVIDIA Plugin

Install the Ingress-nginx Controller

Install and config the Nginx

Install Hardware resource-exporter

Install Redis service

Build and config the Computing Provider

Install AI Inference Dependency

Config and Receive UBI Tasks

Step 1: Prerequisites: Perform Filecoin Commit2 (fil-c2) UBI tasks.

Step 2: Enable UBI tasks in CP's `config.toml`:

Step 3: Initialize a Wallet and Deposit Swan-ETH

Step 4: Initialization

Step 5: Account Management

Step 6: Check the Status of UBI-Task

Start the Computing Provider

CLI of Computing Provider

Getting Help

License

About

Releases

Packages

Languages

License

BerkahCrpto/go-computing-provider

Folders and files

Latest commit

History

Repository files navigation

Computing Provider

Table of Content

Prerequisites

Install the Kubernetes

Install Container Runtime Environment

Option 1: Install the Docker and cri-dockerd （Recommended）

Option 2: Install the Containerd

Optional-Setup a docker registry server

Create a Kubernetes Cluster

Install the Network Plugin

Install the NVIDIA Plugin

Install the Ingress-nginx Controller

Install and config the Nginx

Install Hardware resource-exporter

Install Redis service

Build and config the Computing Provider

Install AI Inference Dependency

Config and Receive UBI Tasks

Step 1: Prerequisites: Perform Filecoin Commit2 (fil-c2) UBI tasks.

Step 2: Enable UBI tasks in CP's config.toml:

Step 3: Initialize a Wallet and Deposit Swan-ETH

Step 4: Initialization

Step 5: Account Management

Step 6: Check the Status of UBI-Task

Start the Computing Provider

CLI of Computing Provider

Getting Help

License

About

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Option 1: Install the `Docker` and `cri-dockerd` （Recommended）

Option 2: Install the `Containerd`

Step 2: Enable UBI tasks in CP's `config.toml`:

Packages