Spin

https://spinframework.dev
Admin
Spin is a framework for building and running event-driven microservice applications using...
Tokens:91,993
Snippets:1,358
Trust Score:8.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### View Template Installation Output

Source: https://spinframework.dev/quickstart

Example output confirming successful installation of the http-py template.

```text
Copying remote template source
Installing template http-py...
Installed 1 template(s)

+---------------------------------------------+
| Name      Description                       |
+=============================================+
| http-py   HTTP request handler using Python |
+---------------------------------------------+
```

--------------------------------

### Install Spin via Installer Script

Source: https://spinframework.dev/install

Use the provided shell script to install Spin along with starter templates and plugins.

```bash
$ curl -fsSL https://spinframework.dev/downloads/install.sh | bash
```

--------------------------------

### Install dependencies and run documentation tests

Source: https://spinframework.dev/v4/contributing-docs

Commands to install Node dependencies, install required system utilities, and execute the test suite for documentation validation.

```bash
$ npm ci
```

```bash
$ brew install coreutils
```

```bash
$ npm run test
```

--------------------------------

### Install Dependencies and Build

Source: https://spinframework.dev/v4/javascript-components

Commands to install project dependencies and build the component for Spin.

```bash
$ cd hello-world
$ npm install
```

```bash
$ spin build
$ spin up
```

--------------------------------

### Run application with OTel tooling

Source: https://spinframework.dev/blog/announcing-spin-3-6

Commands to install the OTel plugin, start the collector, and run the application.

```bash
# Install the `otel` plugin
spin plugin update
spin plugin install otel

# Start the OpenTelemetry collector in the background
spin otel setup

# Run Spin wired up to the OTel collector
spin otel up -- --build --experimental-wasi-otel

# In another terminal
curl localhost:3000
```

--------------------------------

### Install Spin Pluginify

Source: https://spinframework.dev/hub/preview/plugin_spin_pluginify

Use the Spin CLI to install the pluginify plugin.

```bash
spin plugins install pluginify
```

--------------------------------

### Full spin.toml configuration example

Source: https://spinframework.dev/key-value-store-tutorial

Example of a complete spin.toml manifest with key-value store permissions enabled.

```toml
spin_manifest_version = 2

[application]
name = "spin-key-value"
version = "0.1.0"
authors = ["Your Name <your-name@example.com>"]
description = "A simple application that exercises key-value storage."

[[trigger.http]]
route = "/..."
component = "spin-key-value"

[component.spin-key-value]
...
key_value_stores = ["default"]
...
```

--------------------------------

### Install Component Requirements

Source: https://spinframework.dev/v4/python-components

Install dependencies listed in requirements.txt into the virtual environment.

```bash
$ pip3 install -r requirements.txt 
```

--------------------------------

### Install a plugin from a URL

Source: https://spinframework.dev/v4/managing-plugins

Installs a plugin using a direct link to its JSON manifest file.

```bash
$ spin plugins install --url https://github.com/spinframework/spin-befunge-sdk/releases/download/v1.4.0/befunge2wasm.json
```

--------------------------------

### Install Spin templates for TinyGo

Source: https://spinframework.dev/quickstart

Installs Go-based templates from the official Spin repository.

```bash
$ spin templates install --git https://github.com/spinframework/spin --update
Copying remote template source
Installing template redis-go...
Installing template http-go...
+------------------------------------------------------------------------+
| Name                Description                                        |
+========================================================================+
| ... other templates omitted ...                                        |
| http-go             HTTP request handler using (Tiny)Go                |
| redis-go            Redis message handler using (Tiny)Go               |
| ... other templates omitted ...                                        |
+------------------------------------------------------------------------+
```

--------------------------------

### Install Spin templates for Go

Source: https://spinframework.dev/v4/quickstart

Installs Go-based templates from the official Spin repository.

```bash
$ spin templates install --git https://github.com/spinframework/spin --update
Copying remote template source
Installing template redis-go...
Installing template http-go...
+------------------------------------------------------------------------+
| Name                Description                                        |
+========================================================================+
| ... other templates omitted ...                                        |
| http-go             HTTP request handler using Go                      |
| redis-go            Redis message handler using Go                     |
| ... other templates omitted ...                                        |
+------------------------------------------------------------------------+
```

--------------------------------

### Run server with configuration

Source: https://spinframework.dev/blog/mcp-with-wasmcp

Start the server using the specified spin.toml file.

```bash
spin up --from spin.toml
```

--------------------------------

### Configure component files

Source: https://spinframework.dev/manifest-reference

Examples of file and directory mounting configurations.

```toml
[ "images/*.jpg", { source = "assets/images", destination = "/pictures" } ]
```

```toml
"images/*.jpg"
```

```toml
{ source = "assets/images", destination = "/pictures" }
```

--------------------------------

### Start Spin Application

Source: https://spinframework.dev/quickstart

Command to start the Spin application and view available routes.

```bash
$ spin up
Serving http://127.0.0.1:3000
Available Routes:
  hello-typescript: http://127.0.0.1:3000 (wildcard)
```

--------------------------------

### Install project dependencies

Source: https://spinframework.dev/v4/quickstart

Install required packages from requirements.txt.

```bash
$ pip3 install -r requirements.txt 
Collecting spin-sdk==4.0.0 (from -r requirements.txt (line 1))
	Using cached spin_sdk-4.0.0-py3-none-any.whl.metadata (16 kB)
Collecting componentize-py==0.22.0 (from -r requirements.txt (line 2))
	Using cached componentize_py-0.22.0-cp37-abi3-macosx_10_12_x86_64.whl.metadata (3.4 kB)
Using cached spin_sdk-4.0.0-py3-none-any.whl (94 kB)
Using cached componentize_py-0.22.0-cp37-abi3-macosx_10_12_x86_64.whl (38.8 MB)
Installing collected packages: spin-sdk, componentize-py
Successfully installed componentize-py-0.22.0 spin-sdk-4.0.0
```

--------------------------------

### Component Configuration Examples

Source: https://spinframework.dev/v4/manifest-reference

Various configuration examples for component fields including source, files, and network access.

```toml
"The shopping cart API"
```

```toml
"dist/cart.wasm"
```

```toml
{ url = "https://example.com/example.wasm", digest = "sha256:6503...2375" }
```

```toml
{ registry = "registrytest-abcd.fermyon.app", package = "component:hello-world", version="0.0.1" } or { registry = "ttl.sh", package = "user:registrytest", version="1.0.0" }
```

```toml
[ "images/*.jpg", { source = "assets/images", destination = "/pictures" } ]
```

```toml
"images/*.jpg"
```

```toml
{ source = "assets/images", destination = "/pictures" }
```

```toml
[assets/images/test/**/*.*]
```

```toml
["example.com", "localhost:8081"]
```

```toml
["mysql://db.example.com", "*://example.com:4567", "http://127.0.0.1:*"]
```

```toml
["default"]
```

```toml
{ DB_URL = "mysql://spin:spin@localhost/dev" }
```

```toml
[component.cart.build]
command = "npm run build"
```

```toml
[component.cart.variables]
api_base_url = "https://{{ api_host }}/v1"
```

--------------------------------

### Install and Run a Local Spin Plugin

Source: https://spinframework.dev/v4/plugin-authoring

Use the --file flag to install a plugin from a local manifest file during development.

```bash
$ spin plugin install --file practice.json
$ spin practice
```

--------------------------------

### List Installed Templates

Source: https://spinframework.dev/install

Command to display all currently installed templates.

```bash
$ spin templates list
```

--------------------------------

### Install Node.js Polyfill Library

Source: https://spinframework.dev/v4/javascript-components

Install the @spinframework/wasi-ext library to enable limited Node.js API support.

```bash
$ npm install @spinframework/wasi-ext
```

--------------------------------

### Run the component

Source: https://spinframework.dev/v4/go-components

Starts the Spin application locally.

```bash
$ spin up
```

--------------------------------

### Install componentize-py

Source: https://spinframework.dev/v4/build

Install the necessary tool for Python componentization.

```bash
$ pip3 install componentize-py
```

--------------------------------

### Install a plugin from a local file

Source: https://spinframework.dev/v4/managing-plugins

Installs a plugin using a path to a local JSON manifest file.

```bash
$ spin plugins install --file ~/dev/spin-befunge-sdk/befunge2wasm.json
```

--------------------------------

### Install a plugin from the curated catalogue

Source: https://spinframework.dev/v4/managing-plugins

Installs a plugin by name from the official Spin curated repository.

```bash
$ spin plugins install cloud
```

--------------------------------

### Install a Spin plugin

Source: https://spinframework.dev/v4/plugin-authoring

Installs a specific plugin from the Spin catalogue, such as the kube plugin.

```bash
$ spin plugins install kube

```

--------------------------------

### Install Spin via Homebrew

Source: https://spinframework.dev/install

Use the Fermyon tap to manage the Spin installation, including templates and plugins.

```bash
$ brew tap spinframework/tap
```

```bash
$ brew install spinframework/tap/spin
```

--------------------------------

### Install the OTel Plugin

Source: https://spinframework.dev/v4/observing-apps

Commands to update the plugin registry and install the OpenTelemetry plugin for Spin.

```bash
spin plugins update
spin plugins install otel
```

--------------------------------

### Configure component build command

Source: https://spinframework.dev/manifest-reference

Example of build configuration table and command.

```toml
[component.cart.build]
command = "npm run build"
```

--------------------------------

### Install Fermyon Cloud Plugin

Source: https://spinframework.dev/install

Installs the Fermyon Cloud plugin automatically.

```bash
$ spin plugins install cloud --yes
```

--------------------------------

### Application Manifest Configuration Examples

Source: https://spinframework.dev/v4/manifest-reference

Examples of valid values for various fields within the application table of the manifest.

```toml
"hello-world"
```

```toml
"1.0.5"
```

```toml
"The best app for all your world-greeting needs"
```

```toml
["Jane Q Hacker (<dev@example.com>)"]
```

```toml
[“spin-up:3.2”]
```

```toml
[application.trigger.redis]
address = "redis.example.com"
```

--------------------------------

### Complete Application Manifest Example

Source: https://spinframework.dev/v4/variables

A full example of an application manifest incorporating variables and component-level mapping.

```toml
spin_manifest_version = 2

[application]
name = "api-consumer"
version = "0.1.0"
description = "A Spin app that makes API requests"

[variables]
api_token = { required = true }
api_uri = { default = "http://my-api.com" }

[[trigger.http]]
route = "/..."
component = "api-consumer"

[component.api-consumer]
source = "app.wasm"
[component.api-consumer.variables]
token = "{{ api_token }}"
api_uri = "{{ api_uri }}"
api_version = "v1"
```

--------------------------------

### Install wasmcp from source

Source: https://spinframework.dev/blog/mcp-with-wasmcp

Build and install wasmcp directly from the GitHub repository using cargo.

```bash
cargo install --git https://github.com/wasmcp/wasmcp
```

--------------------------------

### Search Available Plugins

Source: https://spinframework.dev/install

Lists all plugins available for installation.

```bash
$ spin plugins search
```

--------------------------------

### Install Spin Templates

Source: https://spinframework.dev/blog/announcing-spin-3-5

Update and install the latest Spin templates from the official repository.

```bash
$ spin templates install --upgrade --git https://github.com/spinframework/spin
```

--------------------------------

### Verify Component Output

Source: https://spinframework.dev/v4/javascript-components

Example command and response for testing the running component.

```bash
$ curl -i localhost:3000
HTTP/1.1 200 OK
date = "2023-11-04T00:00:01Z"
content-type: application/json; charset=utf-8
content-length: 185
server: spin/0.1.0

Here is a fact: Reindeer grow new antlers every year
```

--------------------------------

### Install Spin templates for Python

Source: https://spinframework.dev/quickstart

Installs Python-based templates from the Spin Python SDK repository.

```bash
$ spin templates install --git https://github.com/spinframework/spin-python-sdk --update
Copying remote template source
Installing template http-py...
+---------------------------------------------+
| Name      Description                       |
+=============================================+
| http-py   HTTP request handler using Python |
+---------------------------------------------+
```

--------------------------------

### Configure key-value stores

Source: https://spinframework.dev/manifest-reference

Example of permitted key-value stores.

```toml
["default"]
```

--------------------------------

### Install KV Explorer Template

Source: https://spinframework.dev/hub/preview/template_kv_explorer

Installs or upgrades the KV explorer template from the specified Git repository.

```bash
spin templates install --upgrade --git https://github.com/fermyon/spin-kv-explorer
```

--------------------------------

### Install templates from a local directory

Source: https://spinframework.dev/v4/managing-templates

Use the --dir flag to install templates from a local path. The path must point to the parent directory containing the templates folder.

```bash
$ spin templates install --dir ~/dev/spin-befunge-sdk
```

--------------------------------

### Start Vault Server

Source: https://spinframework.dev/v4/dynamic-configuration

Command to initialize a development Vault server instance.

```bash
$ vault server -dev -dev-root-token-id root
```

--------------------------------

### Example Spin Application Manifest

Source: https://spinframework.dev/v4/manifest-reference

A complete example of a spin.toml manifest file for a Rust-based HTTP application.

```toml
spin_manifest_version = 2

[application]
name = "spin-manifest-example-in-rust"
version = "0.1.0"
authors = ["Fermyon Engineering <engineering@fermyon.com>"]
description = "An example application to generate a Spin manifest file, in this case, via the HTTP Rust template."

[[trigger.http]]
route = "/..."
component = "spin-manifest-example-in-rust"

[component.spin-manifest-example-in-rust]
source = "target/wasm32-wasip2/release/spin_manifest_example_in_rust.wasm"
allowed_outbound_hosts = []
[component.spin-manifest-example-in-rust.build]
command = "cargo build --target wasm32-wasip2 --release"
watch = ["src/**/*.rs", "Cargo.toml"]
```

--------------------------------

### Console Output Examples

Source: https://spinframework.dev/v4/python-components

Expected console output when running the application.

```text
Python
```

```text
<class 'str'>
```

```text
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__',
... abbreviated ...
'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
```

--------------------------------

### Install templates from the Spin Git repository

Source: https://spinframework.dev/v4/managing-templates

Use the --git flag to install templates from a remote repository. You can provide the full URL or a shorthand repository ID.

```bash
$ spin templates install --git https://github.com/spinframework/spin
```

```bash
$ spin templates install --git fermyon/spin
```

--------------------------------

### Preview documentation on localhost

Source: https://spinframework.dev/v4/contributing-docs

Commands to install dependencies and run the Spin application in preview mode.

```bash
$ npm ci
$ cd spin-up-hub
$ npm ci
$ cd ..
$ spin build
$ spin up -e "PREVIEW_MODE=1"
```

--------------------------------

### Selective Copy Example

Source: https://spinframework.dev/v4/contributing-docs

Demonstrates how the selective copy annotation processes commands starting with a dollar sign.

```bash
$ echo "hello"
hello
```

--------------------------------

### Install Specific or Canary Versions of Spin

Source: https://spinframework.dev/install

Pass arguments to the installer script to specify a version or install the latest canary build.

```bash
$ curl -fsSL https://spinframework.dev/downloads/install.sh | bash -s -- -v v1.2.3
```

```bash
$ curl -fsSL https://spinframework.dev/downloads/install.sh | bash -s -- -v canary
```

--------------------------------

### Project directory structure

Source: https://spinframework.dev/v4/build

Example directory structure for a project with a component in a subdirectory.

```text
.
├── deep
│   ├── Cargo.toml
│   └── src
│       └── lib.rs
└── spin.toml
```

--------------------------------

### Configure environment variables

Source: https://spinframework.dev/manifest-reference

Example of setting environment variables for a component.

```toml
{ DB_URL = "mysql://spin:spin@localhost/dev" }
```

--------------------------------

### Build and Run Spin Application

Source: https://spinframework.dev/key-value-store-tutorial

Commands to compile and start the Spin application locally.

```bash
$ spin build
$ spin up
```

--------------------------------

### Initialize a new Spin application

Source: https://spinframework.dev/v4/spin-application-structure

Create a new project using the http-empty template.

```bash
$ spin new -t http-empty
Enter a name for your new application: myapp
Description: My application
```

--------------------------------

### Initialize a Go application with spin new

Source: https://spinframework.dev/v4/writing-apps

Select the http-go or redis-go template to scaffold a new Go-based Spin project.

```bash
$ spin new
Pick a template to start your application with:
  http-c (HTTP request handler using C and the Zig toolchain)
  http-empty (HTTP application with no components)
> http-go (HTTP request handler using Go)
  http-grain (HTTP request handler using Grain)
  http-php (HTTP request handler using PHP)
  http-rust (HTTP request handler using Rust)
Enter a name for your new application: hello_go
Description: My first Go Spin application
HTTP path: /...
```

--------------------------------

### Start Redis and Spin application

Source: https://spinframework.dev/v4/go-components

Commands to initialize the Redis server and launch the Spin application.

```bash
# first, start redis-server on the default port 6379
$ redis-server --port 6379
# then, start the Spin application
$ spin build --up
INFO spin_redis_engine: Connecting to Redis server at redis://localhost:6379
INFO spin_redis_engine: Subscribed component 0 (echo-message) to channel: messages
```

--------------------------------

### Install Python Dependencies

Source: https://spinframework.dev/quickstart

Installs required packages from requirements.txt into the virtual environment.

```bash
$ pip3 install -r requirements.txt 
Collecting spin-sdk==3.1.0 (from -r requirements.txt (line 1))
  Using cached spin_sdk-3.1.0-py3-none-any.whl.metadata (16 kB)
Collecting componentize-py==0.13.3 (from -r requirements.txt (line 2))
  Using cached componentize_py-0.13.3-cp37-abi3-macosx_10_12_x86_64.whl.metadata (3.4 kB)
Using cached spin_sdk-3.1.0-py3-none-any.whl (94 kB)
Using cached componentize_py-0.13.3-cp37-abi3-macosx_10_12_x86_64.whl (38.8 MB)
Installing collected packages: spin-sdk, componentize-py
Successfully installed componentize-py-0.13.3 spin-sdk-3.1.0
```

--------------------------------

### Navigate to Component Directory

Source: https://spinframework.dev/v4/python-components

Change into the newly created component directory.

```bash
$ cd hello-world
```

--------------------------------

### Test changes locally

Source: https://spinframework.dev/hub/contributing

Install dependencies and build the project to verify changes on localhost.

```bash
$ npm install
$ cd spin-up-hub
$ npm install
$ cd ..
$ spin build
$ npm run spin
```

--------------------------------

### Prepare static assets

Source: https://spinframework.dev/v4/spin-application-structure

Create the assets directory and populate it with files to be served.

```bash
$ mkdir assets
$ cp ~/Desktop/my-static-image.jpg assets
$ cp ~/Desktop/old.txt assets
$ cp ~/Desktop/new.txt assets
```

--------------------------------

### Install Spin templates for Rust

Source: https://spinframework.dev/quickstart

Installs Rust-based templates from the official Spin repository.

```bash
$ spin templates install --git https://github.com/spinframework/spin --update
Copying remote template source
Installing template redis-rust...
Installing template http-rust...
... other templates omitted ...
+------------------------------------------------------------------------+
| Name                Description                                        |
+========================================================================+
| ... other templates omitted ...                                        |
| http-rust           HTTP request handler using Rust                    |
| redis-rust          Redis message handler using Rust                   |
| ... other templates omitted ...                                        |
+------------------------------------------------------------------------+
```

--------------------------------

### Initialize a project for a specific environment

Source: https://spinframework.dev/blog/announcing-spin-4-0

Use the -E flag to fetch environment-specific templates and required plugins on demand.

```bash
$ spin new -E <environment>
```

--------------------------------

### Initialize Python Spin Application

Source: https://spinframework.dev/quickstart

Creates a new project directory using the http-py template.

```bash
$ spin new -t http-py hello-python --accept-defaults
```

--------------------------------

### Markdown body example

Source: https://spinframework.dev/hub/contributing

Example content to be placed below the metadata header in the Markdown file.

```markdown
This is the default HTTP trigger template for Rust. It installs by default with the [Spin install script](../../install#installing-spin).

This guide walks you through how to use it: [HTTP Components](../../rust-components#http-components)
```

--------------------------------

### View initial application directory structure

Source: https://spinframework.dev/v4/spin-application-structure

Display the file layout of a newly created empty Spin application.

```text
└── myapp
    └── spin.toml
```

--------------------------------

### Install wasmcp via script

Source: https://spinframework.dev/blog/mcp-with-wasmcp

Use this command to download and install the latest wasmcp binary.

```bash
curl -fsSL https://raw.githubusercontent.com/wasmcp/wasmcp/main/install.sh | bash
```

--------------------------------

### Install Zola template

Source: https://spinframework.dev/hub/preview/template_zola_ssg

Command to install the Zola template for Spin from the specified GitHub repository.

```bash
$ spin templates install --upgrade --git https://github.com/karthik2804/spin-zola
```

--------------------------------

### Initialize a new Spin application

Source: https://spinframework.dev/key-value-store-tutorial

Commands to scaffold a new Spin project using specific language templates.

```bash
$ spin new -t http-rust spin-key-value

# Reference: https://github.com/spinframework/spin-rust-sdk/tree/stable/examples/rust-key-value
```

```bash
$ spin new -t http-ts spin-key-value
$ cd spin-key-value
$ npm install @spinframework/spin-kv

# Reference: https://github.com/spinframework/spin-js-sdk/tree/main/examples/spin-host-apis/spin-kv
```

```bash
$ spin new -t http-py spin-key-value

# Reference: https://github.com/spinframework/spin-python-sdk/tree/main/examples/spin-kv
```

```bash
$ spin new -t http-go spin-key-value

# Reference: https://github.com/spinframework/spin-go-sdk/tree/stable/examples/key-value
```

--------------------------------

### No Copy Annotation Example

Source: https://spinframework.dev/v4/contributing-docs

Example of using the nocpy annotation to prevent code from being copied by the user.

```text
<!-- @nocpy -->

```text
Some generic code not intended for copying/pasting
```
```

```text
Some generic code not intended for copying/pasting
```

--------------------------------

### Initialize and run a Zola Spin application

Source: https://spinframework.dev/hub/preview/template_zola_ssg

Use these commands to scaffold a new Zola project and start the Spin development server.

```bash
$ spin new zola-ssg my-blog
$ cd my-blog
$ spin build --up
```

--------------------------------

### Install Cron Trigger Template

Source: https://spinframework.dev/v4/triggers

Command to install the cron trigger project template from the GitHub repository.

```bash
spin templates install --git https://github.com/spinframework/spin-trigger-cron
```

--------------------------------

### Install Cron Trigger Plugin

Source: https://spinframework.dev/v4/triggers

Command to install the experimental cron trigger plugin from the provided URL.

```bash
spin plugins install --url https://github.com/spinframework/spin-trigger-cron/releases/download/canary/trigger-cron.json
```

--------------------------------

### Install Spin templates for TypeScript

Source: https://spinframework.dev/quickstart

Installs TypeScript and JavaScript templates from the Spin JS SDK repository.

```bash
$ spin templates install --git https://github.com/spinframework/spin-js-sdk --update
Copying remote template source
Installing template http-js...
Installing template http-ts...
+------------------------------------------------------------------------+
| Name                Description                                        |
+========================================================================+
| http-js             HTTP request handler using Javascript              |
| http-ts             HTTP request handler using Typescript              |
+------------------------------------------------------------------------+
```

--------------------------------

### Initialize a Python application with spin new

Source: https://spinframework.dev/writing-apps

Use the http-py template to scaffold a Python HTTP application. Redis support is not currently available for Python.

```bash
$ spin new
Pick a template to start your application with:
> http-py (HTTP request handler using Python)
Enter a name for your new application: hello_python
Description: My first Python Spin application
HTTP path: /...
```

--------------------------------

### Install a specific plugin version

Source: https://spinframework.dev/v4/managing-plugins

Uses the --version flag to install a particular release of a plugin.

```bash
$ spin plugins install cloud --version 0.9.1
```

--------------------------------

### Build and Run Spin with Runtime Config

Source: https://spinframework.dev/v4/dynamic-configuration

Commands to build the application and start it using a specific runtime configuration file.

```bash
$ spin build
$ spin up --runtime-config-file runtime-config.toml
```

--------------------------------

### spin templates install

Source: https://spinframework.dev/v4/cli-reference

Installs templates from a Git repository, local directory, or tarball into the local template store.

```APIDOC
## spin templates install

### Description
Install templates from a Git repository or local directory. The files are copied to the local template store.

### Usage
`spin templates install [OPTIONS]`

### Options
- **--branch** (string) - Optional - The optional branch of the git repository
- **--dir** (string) - Optional - Local directory containing the template(s) to install
- **--git** (string) - Optional - The URL of the templates git repository
- **--tar** (string) - Optional - URL to a tarball in .tar.gz format
- **--upgrade** (flag) - Optional - If present, updates existing templates instead of skipping
```

--------------------------------

### Install templates from a remote tarball

Source: https://spinframework.dev/v4/managing-templates

Use the --tar flag to install templates from a compressed archive URL.

```bash
$ spin templates install --tar https://github.com/spinframework/spin/archive/refs/tags/v9.8.7.tar.gz
```

--------------------------------

### Initialize a new Spin project with Cargo

Source: https://spinframework.dev/v4/rust-components

Use the --lib flag to ensure the project is configured as a library.

```bash
$ cargo init --lib
```

--------------------------------

### List files and script extensions by operating system

Source: https://spinframework.dev/v4/contributing-docs

Examples of listing files and identifying script extensions for Windows and Linux environments.

```bash
$ dir hello_spin
```

```bash
hello.bat
test.bat
```

```bash
$ ls
```

```bash
hello.sh
test.sh
```

--------------------------------

### Build Python components with spin build

Source: https://spinframework.dev/v4/quickstart

Sets up a virtual environment and builds the Python component.

```bash
$ python3 -m venv venv
$ source venv/bin/activate
```

```bash
C:\Work> python3 -m venv venv
C:\Work> venv\Scripts\activate
```

```bash
$ pip3 install -r requirements.txt
```

```bash
$ spin build
Building component hello-python with `componentize-py -w spin:up/http-trigger@4.0.0 componentize app -o app.wasm
Component built successfully
Finished building all Spin components
```

```toml
[component.hello-python.build]
command = "componentize-py -w spin:up/http-trigger@4.0.0 componentize app -o app.wasm"
```

--------------------------------

### Upgrade local templates

Source: https://spinframework.dev/v4/managing-templates

Use the --upgrade flag with the install command to update templates installed from a local directory.

```bash
$ spin templates install --dir ~/dev/spin-befunge-sdk --upgrade
```

--------------------------------

### Install templates from a specific branch

Source: https://spinframework.dev/v4/managing-templates

Specify a branch or tag using the --branch option when installing from a Git repository.

```bash
$ spin templates install --git https://github.com/spinframework/spin --branch spin/templates/v0.8
```

--------------------------------

### Perform Key Value operations in Go

Source: https://spinframework.dev/v4/kv-store-api-guide

Demonstrates opening the default store and performing get and set operations in Go.

```go
import "github.com/spinframework/spin-go-sdk/v3/kv"

func example() error {
    store, err := kv.OpenDefault()
    if err != nil {
        return err
    }
    previous, err := store.Get("mykey")
    return store.Set("mykey", []byte("myvalue"))
}
```

--------------------------------

### Install Spin using Cargo

Source: https://spinframework.dev/install

Clone the repository and install Spin via Cargo, ensuring the required WebAssembly targets are added.

```bash
$ git clone https://github.com/spinframework/spin
$ cd spin
$ # Check out the latest tagged release
$ # git checkout <latest release>
$ rustup target add wasm32-wasip1
$ rustup target add wasm32-unknown-unknown
$ cargo install --locked --path .
$ spin --help
```

--------------------------------

### Upgrade installed templates

Source: https://spinframework.dev/v4/managing-templates

Run the upgrade command to interactively select repositories to update to the latest version.

```bash
$ spin templates upgrade
Select repos to upgrade. Use Space to select/deselect and Enter to confirm selection.
  [x] https://github.com/spinframework/spin-python-sdk
  [ ] https://github.com/spinframework/spin (at spin/templates/v1.0)
> [x] https://github.com/spinframework/spin-js-sdk
```

--------------------------------

### Install build dependencies on Debian-based systems

Source: https://spinframework.dev/install

Install the required toolchain and libraries for building Spin on Linux distributions like Ubuntu.

```bash
$ sudo apt-get install build-essential libssl-dev pkg-config
```

--------------------------------

### Configure spin.toml for Python

Source: https://spinframework.dev/v4/python-components

Example configuration file for a Spin Python component, including the build command.

```toml
spin_manifest_version = 2

[application]
name = "hello-world"
version = "0.1.0"
authors = ["Your Name <your-name@example.com>"]
description = ""

[[trigger.http]]
route = "/..."
component = "hello-world"

[component.hello-world]
source = "app.wasm"
[component.hello-world.build]
command = "componentize-py -w spin:up/http-trigger@4.0.0 componentize app -o app.wasm"
```

--------------------------------

### Fetch content length via HTTP GET

Source: https://spinframework.dev/blog/announcing-spin-3-5

An asynchronous helper function that sends an HTTP GET request and parses the Content-Length header.

```rust
async fn get_content_length(url: &str) -> anyhow::Result<Option<u64>> {
    let request = Request::get(url).body(EmptyBody::new())?;
    let response = send(request).await?;
    let cl_header = response.headers().get("content-length");
    let cl = cl_header.and_then(|hval| hval.to_str().ok()).and_then(|hval| hval.parse().ok());
    Ok(cl)
}
```

--------------------------------

### spin plugins install

Source: https://spinframework.dev/v4/cli-reference

Installs a Spin plugin from a manifest file or remote URL. The plugin binary and manifest are copied to the local Spin plugins directory.

```APIDOC
## spin plugins install

### Description
Install a plugin from a manifest. The binary file and manifest of the plugin is copied to the local Spin plugins directory.

### Usage
`spin plugins install [OPTIONS] [PLUGIN_NAME]`

### Arguments
- **PLUGIN_NAME** (string) - Optional - Name of Spin plugin

### Options
- **-E, --TARGET_ENV** (string) - Optional - The Spin platform or runtime for which you want to install plugins
- **--auth-header-value** (string) - Optional - Provide the value for the authorization header to be able to install a plugin from a private repository
- **-f, --file** (string) - Optional - Path to local plugin manifest
- **--override-compatibility-check** (boolean) - Optional - Overrides a failed compatibility check of the plugin with the current version of Spin
- **-u, --url** (string) - Optional - URL of remote plugin manifest to install
- **-v, --version** (string) - Optional - Specific version of a plugin to be install from the centralized plugins repository
- **-y, --yes** (boolean) - Optional - Skips prompt to accept the installation of the plugin
```
Tokens:
Raw