Filebase
HomepageFilebase DashboardDiscordBlog
  • 👋Welcome to Filebase!
  • Getting Started
    • FAQ
    • Service Limits
    • Getting Started Guides
      • Pin Your First File To IPFS
      • Developer Quick Start Guide
  • IPFS Concepts
    • What is IPFS?
    • What is an IPFS CID?
    • What is IPFS Pinning?
    • What is an IPFS Gateway?
  • IPFS Pinning
    • Pinning Files
    • Listing Files
    • Deleting Files
    • Event Notifications
  • IPNS Names
    • Managing Names
  • Dedicated IPFS Gateways
    • Managing Dedicated Gateways
    • Access Controls
    • Image Optimizations
    • Adding a Custom Domain
  • API Documentation
    • S3-Compatible API
      • Cross Origin Resource Sharing (CORS)
        • Create and Apply a CORS Rule to a Filebase Bucket
        • Deep Dive: Cross Origin Resource Sharing (CORS)
      • Pre-Signed URLs
    • Filebase Platform APIs
    • IPFS Pinning Service API
  • Code Development + SDKs
    • Code Development
      • Apache Libcloud - Python
      • Apostrophe CMS
      • AWS Lambda - NodeJS
      • AWS Lambda - Python
      • AWS SDK - Go (Golang)
      • AWS SDK - Java
      • AWS SDK - JavaScript
      • AWS SDK - .NET
      • AWS SDK - PHP
      • AWS SDK - Python
      • AWS SDK - Ruby
      • Code Examples
        • How To Utilize Filebase with NodeJS
      • DataCamp
      • Dart / Flutter
      • Django
      • Docker
        • Docker Volume Backup
      • Elixir Phoenix
      • Filebase NPM Package
      • Fog.io - Ruby
      • Google App Scripts
      • Integrated Haskell Platform
      • Laravel
      • Nuxt
      • Paperspace
      • Postman
      • Reading a JSON File
      • UNA
      • Unity
      • Uppy AWS S3 Plugin
      • Vue
      • Watcher for NodeJS
      • Webpack S3 Plugin
      • Xamarin
    • SDK Examples: Pinning Files and Folders to IPFS
      • AWS SDK for .NET
      • AWS SDK for Go
      • AWS SDK for JavaScript
      • AWS SDK for PHP
      • AWS SDK for Python
      • AWS SDK for Ruby
  • Archive
    • Content Archive
      • IPFS Getting Started Guide
      • Web Console Getting Started Guide
      • IPFS Tools
        • IPFS CLI
        • IPFS Desktop
        • IPFS Pin Sync
        • IPFS Pinning Service API
        • IPFS3up
      • Third Party Tools and Clients
        • Backup Client Configurations
          • AhsayCBS
          • BackupAssist Classic
          • BackupAssist ER
          • BackupNinja
          • BackupSheep
          • Bacula Enterprise Edition
          • CloudBacko
          • CloudBerry Backup
          • Cloudron
          • cPanel
          • Comet
          • Commvault
          • Duplicacy
          • Ghost IPFS Storage Adapter
          • IPFS Pinning GitHub Action
          • JetBackup
          • Kopia
          • MoveBot
          • MSP360 Online Backup
          • oDrive
          • Photos+ Cloud Library
          • qBackup
          • S3 Uploader for GitHub Actions
          • SimpleBackups
          • SnapShooter
          • Strapi Provider Plugin
          • Veeam
          • Wordpress
            • Media Cloud
            • XCloner
          • Zerto
        • CLI Tools
          • Ansible
          • Apache Pulsar
          • AWS CLI
            • How To Delete Data with AWS CLI
            • What is Multipart Upload?
          • Bash
            • Backup Files to IPFS with Bash
            • Laravel Backup with Bash
            • MongoDB Backup with Bash
            • PostgreSQL Backup with Bash
            • Wordpress Backup with Bash
          • cURL
          • Elasticsearch
          • IPFS-CAR
          • IPFScrape
          • IPGet
          • Jenkins
          • JFrog Artifactory
          • Kubernetes
            • Backup and Restore InFluxDB to Filebase with TrilioVault
            • CSI-S3
            • Kasten K10
            • Kerberos Vault
            • Longhorn.io
            • Stash for Kubernetes
            • Velero
          • Litestream
          • Minty
          • MongoDB
          • MoSMB
          • MySQL
          • Next.js .CAR File Upload
          • NFT Image Generator
          • NGINX S3 Gateway
          • Pinning Docker Images to IPFS
          • Pinning Encrypted Files to IPFS
          • PowerShell
            • Calculate the Size of Filebase Buckets using PowerShell
          • Rclone
            • Backing Up DigitalOcean Spaces to Filebase using Rclone
          • Restic
          • S3cmd
          • S3Express
          • S3FS-FUSE
          • S3QL
          • S3Surfer
          • S4cmd
          • SeaweedFS
          • Tableland
        • Content Delivery Networks
          • Bunny CDN
          • CloudFront CDN
          • Fastly CDN
        • File Management Client Configurations
          • Airbyte
          • Arq
          • Astiga
          • AWS Rekognition
          • AWS S3 Manager - iOS App
          • BucketAnywhere for S3 - Android App
          • CentreStack
          • CloudFlyer
          • Cloudfser
          • Couchdrop
          • CrossFTP
          • CyberDuck
            • How To Delete Data with CyberDuck
          • Dropshare
          • Duplicati
          • FileBrowserGO
          • Flexify.IO
          • ForkLift
          • Goofys
          • Joplin
          • LucidLink
          • MASV
          • Matrix Synapse
          • MinIO Gateway for S3
          • Mountain Duck
          • NetDrive
          • Nexfs
          • NextCloud
          • Nodeum
          • ownCloud
          • Plesk
          • Pure Storage FlashBlade
          • RaiDrive
          • S3 Browser
          • ShareX
          • SmartFTP
          • StableBit Cloud Drive
          • Storage Made Easy Enterprise File Fabric
          • WinSCP
        • NAS Device Configurations
          • Buffalo TeraStation
          • Datadobi DobiProtect
          • Netapp ONTAP Select
          • OpenDrives Atlas
          • Synology Hyper Backup
          • TrueNAS CORE
      • Knowledge Base
        • Deep Dives
          • Deep Dive: Blockchains
          • Deep Dive: Decentralized Compute
          • Deep Dive: Decentralized Digital Identity
          • Deep Dive: Decentralized Storage
          • Deep Dive: Erasure Coding
          • Deep Dive: Geo-Redundancy
          • Deep Dive: Metadata
          • Deep Dive: Metaverse
          • Deep Dive: NFTs
          • Deep Dive: Web3
        • Filebase eBooks
        • Filebase One-Pagers
        • Filebase Whitepapers
        • Web3 Tutorials
          • Alchemy
            • Alchemy: Build a dApp That Provides Real-Time Ethereum Transaction Notifications
            • Alchemy: Create a Full-Stack dApp
            • Alchemy: Create a Hello World Smart Contract
            • Alchemy: Create Your Own ERC20 Cryptocurrency
            • Alchemy: Decentralized Youtube
            • Alchemy: How to Create and Mint an NFT using Filebase
            • Alchemy: How to Mint an NFT Using Web3.js
            • Alchemy: Using The Alchemy SDK with NFTs Minted Through thirdweb
          • Agoric
            • Agoric: Create a DeFi dApp Using Agoric That’s Stored on Filebase
          • AirSwap
            • AirSwap: Track NFT Contract Addresses with AirSwap CLI
          • ArcBlock
            • ArcBlock: Running an ArcBlock Blocket Server on IPFS
          • Ankr
            • Ankr: Create a Truffle Project with Ankr and Filebase
            • Ankr: Deploy a Smart Contract on Polygon using Ankr that is backed up to Filebase
          • Avalanche
            • Avalanche: How To Launch a Generative NFT Collection With Avalanche and IPFS
          • Backing Up NFTs
          • Brownie
            • Brownie: Create and Mint an NFT Using Brownie
          • Bueno
            • Bueno: How to Create a Generative NFT Collection with Bueno
          • Cardano
            • Cardano: Submit Cardano Blockchain Transactions with Embedded Metadata Stored on Filebase
          • Ceramic
            • Ceramic: How to Host a Ceramic Node Using Decentralized Storage
          • Create-IPFS-app
          • Cosmos
            • Cosmos: Storing Cosmos Chain Governance Metadata on IPFS
          • DeCommerce
          • Ethereum Name Service
            • ENS: Configure an ENS Domain to use a Filebase IPFS Dedicated Gateway
          • Figment Datahub
            • Figment Datahub and Avalanche: Make an e-Voting dApp Using Figment Datahub, Avalanche, and Filebase
            • Figment Datahub and Celo Network: Create an ERC1155 NFT on the Celo Network using Figment Datahub and Objects Stored on Filebase
          • Flow
            • Flow: How to Create an NFT Marketplace with Filebase + Flow
          • Fauna
            • Fauna: Host an Application on IPFS with IPFS Dedicated Gateways
          • Ganache
            • Ganache: Create a dApp Hosted on IPFS
          • GUN
            • GUN: Create a Decentralized Chat App with GUN and IPFS
          • Hardhat
            • Hardhat: Creating an NFT Contract using Hardhat and Setting NFT Metadata using IPFS on Filebase
          • Harmony
            • Harmony: Deploy an HRC721 NFT on Harmony with IPFS
          • Hosting a Form on IPFS
          • iExec
            • iExec: Using iExec and Tee Worker to Create Apps that Use Datasets Stored on Filebase
          • Infura
            • Infura: Build dApp Frontends with Infura, React, and IPFS
            • Infura: Create an NFT Contract Factory with Metadata stored on IPFS
          • Lens Protocol
            • Lens Protocol: Build a Decentralized Social Media Network Stored on IPFS
          • LIT Protocol
            • LIT Protocol: Create a MintLIT NFT with LIT Protocol and IPFS
          • LivePeer
            • LivePeer: Mint a Video NFT with LivePeer
          • Macrometa
            • Macrometa: Track IPFS Files with Macrometa
          • Mina Protocol
            • Mina Protocol: Create a Simple zkApp with Mina Protocol and IPFS
          • NEAR Protocol
            • NEAR Protocol: Storing Off-Chain Data on IPFS using Filebase
          • NFTPort
            • NFTPort: Create an NFT Collection with NFTPort
          • Ocean Protocol
            • Ocean Protocol: Publish Data NFTs Stored on IPFS using Ocean Protocol
          • Pin Tezos Tokens Tool
          • Polkadot
            • Polkadot: Deploy a Polkadot dApp on Decentralized Storage
          • Polygon
            • Polygon: Building an App NFT With Polygon
            • Polygon: Make a Donation App with IPFS and Polygon
          • Python
            • Generating NFT Metadata with Python
          • QuickNode
            • QuickNode: Create a Token dApp using QuickNode
          • Remix
            • Remix: Create a Web App with Remix to Upload to Decentralized Storage
          • Remix IDE
            • Remix IDE: Creating Interactive NFTs with IPFS and Remix IDE
          • Secret Network
            • Secret Network: Create an NFT on Secret Network with Data Stored on IPFS
          • Stargaze
            • Stargaze: Create an NFT Collection Using IPFS and Stargaze
          • Starknet
            • Starknet: Create a HardHat Project Using A Starknet Plugin Hosted On IPFS
          • Studio 721
            • Studio 721: Create an NFT Collection with Studio 721 and IPFS
          • Solana
            • Solana: Minting an NFT Using Sugar, Candy Machine, and Filebase
          • Subsquid
            • Subsquid: Querying NFT Data using Subsquid and a Filebase IPFS Dedicated Gateway
          • Tailwind CSS
            • Tailwind CSS: Build an Image Gallery App with IPFS and Tailwind CSS
          • Tatum
            • Tatum: How To Mint NFTs on Solana with Tatum
          • Tezos
            • Tezos: Create an NFT on the Tezos Network using IPFS on Filebase
          • thirdweb
            • thirdweb: Build an NFT Loot Box with thirdweb and IPFS
            • thirdweb: Build an NFT Minting Page with thirdweb, IPFS, RainbowKit, and WAGMI
            • thirdweb: Create a Discord Bot That Gives Roles to NFT Holders
            • thirdweb: Create a Gated Website Using NFTs and IPFS
            • thirdweb: Create an NFT Marketplace with thirdweb and IPFS
            • thirdweb: Release an NFT Drop Using thirdweb and IPFS
          • useDApp
            • useDApp: Create a dApp using useDApp and IPFS
          • Unstoppable Domains
            • Unstoppable Domains: Create a Decentralized Website Using Unstoppable Domains and IPFS Folders
            • Unstoppable Domains: Deploy a Decentralized Blog Using Unstoppable Domains, Akash, and IPFS
            • Unstoppable Domains: IPFS Configuration
          • Vultr
            • Vultr: Store Bedrock Minecraft Worlds on Decentralized Storage
            • Vultr: Store Forge Minecraft Worlds on Decentralized Storage
            • Vultr: Store PaperSpigot Minecraft Worlds on Decentralized Storage
            • Vultr: Store Vanilla Minecraft Worlds on Decentralized Storage
          • Waffle
            • Waffle: Deploy a Smart Contract with Waffle That’s Stored on IPFS
          • Walt.id
            • Walt.id: Mint an NFT with Walt.id and Filebase
          • Web3 Toolbox
            • Web3 Toolbox: Building an NFT Drop With Web3 Toolbox
Powered by GitBook
On this page
  • What is iExec?
  • 1. Install the iExec SDK CLI package with the following command:
  • 2. Create a new Wallet file:
  • 3. Initialize your iExec project:
  • 4. We will use the iExec testnet, called Viviani, for our project. Next, initialize the default remote storage:
  • 5. Now initialize your app:
  • 6. Then deploy this default app on the Viviani network:
  • 7. Confirm it was deployed successfully by checking your list of deployed apps:
  • 8. Now, to run your app you will need RLC tokens.
  • 9. Confirm the transaction was successful by checking your wallet’s balance:
  • 10. Now it's time to run your application. Use the following command:
  • 11. Download the result of your task with the command:
  • 12. View the contents of your task result file:
  • 13. Up until now, we’ve been using the default storage configuration for iExec, which is IPFS managed by iExec.
  • 14. For this tutorial, we’ll use a sample dataset that we’ll initiate with the command:
  • 15. Now we’ll create a sample dataset with the command:
  • 16. Then encrypt your dataset:
  • 17. You can upload files to Filebase using two methods: the Filebase Web Console, or the Filebase S3-compatible API.
  • 18. To use the web console, navigate to console.filebase.com.
  • 19. Select ‘Buckets’ from the left sidebar menu, or navigate to console.filebase.com/buckets.
  • 20. Enter a bucket name and choose the IPFS storage network to create the bucket.
  • 21. Next, select the bucket from your list of buckets, then select ‘Upload’ in the top right corner to upload your files.
  • 22. Select your files to be uploaded.
  • 23. You can view the IPFS CID from the bucket object list in the CID column, or you can click on each uploaded object to display the metadata for the object to view the IPFS CID.
  • 24. Next, open the iexec.json file, navigate to the dataset section, and edit the following lines:
  • 25. Deploy your dataset on the network with the command:
  • 26. Now we need to push the encryption key to the Secret Management Service so that the deployed dataset can be used for authorized applications.
  • 27. Now let’s deploy an application that uses this dataset.
  • 28. In the src/ folder, open the new file called app.py and input the following code:
  • 29. Then build the TEE docker image by editing the Dockerfile we created previously to reflect the following content:
  • 30. Open the sconify.sh file and input the following code:
  • 31. Then run the sconify.sh script to build the TEE app:
  • 32. Now let’s deploy the TEE app on the iExec network. Start by initializing the application:
  • 33. Get the enclave fingerprint for your TEE image:
  • 34. Then edit the iexec.json file to add the following configuration details:
  • 35. Deploy the app on the iExec testnet:
  • 36. Then run the TEE app:

Was this helpful?

  1. Archive
  2. Content Archive
  3. Knowledge Base
  4. Web3 Tutorials
  5. iExec

iExec: Using iExec and Tee Worker to Create Apps that Use Datasets Stored on Filebase

Learn how to use iExec and Tee Worker to create apps that use datasets stored on Filebase.

PreviousiExecNextInfura

Last updated 9 months ago

Was this helpful?

What is iExec?

The iExec network enables decentralized docker app deployment and monetization on the blockchain by connecting cloud resource sellers with cloud resource buyers and encourages an ecosystem of decentralized, autonomous, privacy-preserving applications.

Read below to learn how to use iExec and its Tee Worker Application to create apps that use datasets stored on Filebase.

Prerequisites:

1. Install the iExec SDK CLI package with the following command:

npm i -g iexec

2. Create a new Wallet file:

iexec wallet create

You will be prompted to set a password on this wallet file. Take note of this password since there is no way to recover it if forgotten.

3. Initialize your iExec project:

mkdir ~/iexec-projects

cd ~/iexec-projects

iexec init --skip-wallet

4. We will use the iExec testnet, called Viviani, for our project. Next, initialize the default remote storage:

iexec storage init --chain viviani

5. Now initialize your app:

iexec app init

The default app is the public docker image iexechub/python-hello-world.

6. Then deploy this default app on the Viviani network:

iexec app deploy --chain viviani

7. Confirm it was deployed successfully by checking your list of deployed apps:

iexec app show --chain viviani

8. Now, to run your app you will need RLC tokens.

Since we’re running on the testnet, we can get some test RLC with the command:

iexec wallet get-RLC --chain viviani

9. Confirm the transaction was successful by checking your wallet’s balance:

iexec wallet show --chain viviani

10. Now it's time to run your application. Use the following command:

iexec app run --args APP_NAME --watch --chain viviani

Replace APP_NAME with your desired Application name.

11. Download the result of your task with the command:

iexec task show TASK_ID --download my-result --chain viviani

Replace TASK_ID with the Task ID value from the last command’s output.

12. View the contents of your task result file:

unzip my-result.zip -d my-result

cat my-result/result.txt

13. Up until now, we’ve been using the default storage configuration for iExec, which is IPFS managed by iExec.

For private datasets and assets, this method is not recommended, so we’ll now switch to using Filebase for our private storage backend.

14. For this tutorial, we’ll use a sample dataset that we’ll initiate with the command:

iexec dataset init --encrypted

This command makes 3 new directories:

  • datasets/encrypted

  • datasets/original

  • .secrets/datasets

A new section will be appended to the iexec.json file called ‘datasets’.

15. Now we’ll create a sample dataset with the command:

echo "Hello Filebase!" > datasets/original/filebase-test-dataset.txt

16. Then encrypt your dataset:

iexec dataset encrypt

Take note of the checksum value that is returned from this command.

This command created the file datasets/encrypted/filebase-test-dataset.txt.enc. Let’s upload this file to Filebase.

17. You can upload files to Filebase using two methods: the Filebase Web Console, or the Filebase S3-compatible API.

Either method will require an IPFS bucket which must be created from the Web Console.

Select ‘Create Bucket’ in the top right corner to create a new bucket.

20. Enter a bucket name and choose the IPFS storage network to create the bucket.

Bucket names must be unique across all Filebase users, be between 3 and 63 characters long, and can contain only lowercase characters, numbers, and dashes.

21. Next, select the bucket from your list of buckets, then select ‘Upload’ in the top right corner to upload your files.

22. Select your files to be uploaded.

Once uploaded, they will be listed in the bucket.

23. You can view the IPFS CID from the bucket object list in the CID column, or you can click on each uploaded object to display the metadata for the object to view the IPFS CID.

Take note of this CID, since we will use it in the next step.

24. Next, open the iexec.json file, navigate to the dataset section, and edit the following lines:

"dataset": {
    "owner": "0x-your-wallet-address",
    "name": "Encrypted Filebase dataset",
    "multiaddr": "https://ipfs.filebase.io/ipfs/[IPFS_CID]",
    "checksum": "0x0000000000000000000000000000000000000000000000000000000000000000"
  }

Replace the IPFS_CID with the IPFS CID from the uploaded dataset in your Filebase bucket.

25. Deploy your dataset on the network with the command:

iexec dataset deploy --chain viviani

26. Now we need to push the encryption key to the Secret Management Service so that the deployed dataset can be used for authorized applications.

To get the encryption key for this dataset and push it to the testnet, use the following commands:

Note: This workflow is fine for debugging purposes on the testnet, but is not recommended to store secrets for production environments.

sed -i 's|"viviani": {},|"viviani": { "sms": "<https://v7.sms.debug-tee-services.viviani.iex.ec>" },|g' chain.json

iexec dataset push-secret --chain viviani

27. Now let’s deploy an application that uses this dataset.

First, make a new directory for this project, initiate iExec inside this directory, and create some empty files that we’ll need later.

mkdir my-tee-dataset-app && cd my-tee-dataset-app

iexec init --skip-wallet

mkdir src

touch src/app.py

touch Dockerfile

touch sconify.sh

28. In the src/ folder, open the new file called app.py and input the following code:

import json
import os

from pyfiglet import Figlet

iexec_out = os.environ['IEXEC_OUT']
iexec_in = os.environ['IEXEC_IN']
dataset_filename = os.environ['IEXEC_DATASET_FILENAME']

text = ''

# Check the confidential file exists and open it
try:
    dataset_file = open(iexec_in + '/' + dataset_filename, 'r')
    dataset = dataset_file.read()
    text = Figlet().renderText(dataset)
except OSError:
    print('confidential file does not exists')
    exit(1)

print(text)

# Append some results in /iexec_out/
with open(iexec_out + '/result.txt', 'w+') as fout:
    fout.write(text)

# Declare everything is computed
with open(iexec_out + '/computed.json', 'w+') as f:
    json.dump({"deterministic-output-path": iexec_out + '/result.txt'}, f)

29. Then build the TEE docker image by editing the Dockerfile we created previously to reflect the following content:

FROM python:3.7.3-alpine3.10
RUN pip3 install pyfiglet
COPY ./src /app
ENTRYPOINT ["python3", "/app/app.py"]

30. Open the sconify.sh file and input the following code:

#!/bin/bash

# declare the app entrypoint
ENTRYPOINT="python /app/app.py"
# declare an image name
IMG_NAME=python-dataset-app

IMG_FROM=${IMG_NAME}:temp-non-tee
IMG_TO=${IMG_NAME}:tee-debug

# build the regular non-TEE image
docker build . -t ${IMG_FROM}

# run the sconifier to build the TEE image based on the non-TEE image
docker run -it \\
            -v /var/run/docker.sock:/var/run/docker.sock \\
            registry.scontain.com:5050/scone-production/iexec-sconify-image:5.3.7 \\
            sconify_iexec \\
            --name=${IMG_NAME} \\
            --from=${IMG_FROM} \\
            --to=${IMG_TO} \\
            --binary-fs \\
            --fs-dir=/app \\
            --host-path=/etc/hosts \\
            --host-path=/etc/resolv.conf \\
            --binary=/usr/local/bin/python3.7 \\
            --heap=1G \\
            --dlopen=2 \\
            --no-color \\
            --verbose \\
            --command=${ENTRYPOINT} \\
            && echo -e "\\n------------------\\n" \\
            && echo "successfully built TEE docker image => ${IMG_TO}" \\
            && echo "application mrenclave.fingerprint is $(docker run -it --rm -e SCONE_HASH=1 ${IMG_TO})"

31. Then run the sconify.sh script to build the TEE app:

./sconify.sh

32. Now let’s deploy the TEE app on the iExec network. Start by initializing the application:

iexec app init --tee

33. Get the enclave fingerprint for your TEE image:

docker run -it --rm -e SCONE_HASH=1 python-dataset-app:tee-debug

Take note of this, we will use it in the next step.

34. Then edit the iexec.json file to add the following configuration details:

"mrenclave": {
      "provider": "SCONE", // TEE provider (keep default value)
      "version": "v5", // Scone version (keep default value)
      "entrypoint": "node /app/app.py",
      "heapSize": 1073741824, // heap size in bytes (1GB)
      "fingerprint": "ENCLAVE_FINGERPRINT" 
    }

Replace the ENCLAVE_FINGERPRINT value with the enclave fingerprint you took note of in the last step.

35. Deploy the app on the iExec testnet:

iexec app deploy --chain viviani

36. Then run the TEE app:

iexec app run APP_ADDRESS --tag tee --dataset DATASET_ADDRESS --workerpool 0xe6806E69BA8650AF23264702ddD43C4DCe35CcCe --watch --chain viviani

Replace the APP_ADDRESS value with your TEE app address, and the DATASET_ADDRESS with the address of your dataset from Step 25.

Your app is now deployed using your encrypted dataset stored on Filebase!

18. To use the web console, navigate to .

If you don’t have an account already, , then log in.

19. Select ‘Buckets’ from the left sidebar menu, or navigate to .

console.filebase.com
sign up
console.filebase.com/buckets
Docker
Nodejs
Sign up
here