diff --git a/README.md b/README.md index 2d61f0089..992b6f810 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ Prerequisites to run the website locally: - [npm and node](https://docs.npmjs.com/cli/v8/configuring-npm/install) -- [Spin](https://developer.fermyon.com/spin/quickstart) +- [Spin](https://spinframework.dev/quickstart) Build and run the website locally: @@ -20,4 +20,4 @@ spin watch # Uses spin watch to run the website and reload when content changes. 2. View the website at `http://localhost:3000`. -If you would like to edit the contents of the [developer.fermyon.com](https://developer.fermyon.com/) website and contribute your changes, please visit the [Contributing to Docs](https://developer.fermyon.com/spin/contributing-docs) page. +If you would like to edit the contents of the [developer.fermyon.com](https://developer.fermyon.com/) website and contribute your changes, please visit the [Contributing to Docs](https://developer.fermyon.com/common/contributing-docs) page. \ No newline at end of file diff --git a/content/api/hub/contributing.md b/content/api/hub/contributing.md index fe980ef30..14cebd194 100644 --- a/content/api/hub/contributing.md +++ b/content/api/hub/contributing.md @@ -108,9 +108,9 @@ url = "https://github.com/spinframework/spin/tree/main/templates/http-rust" Be sure to make a description of the hub item in the body (below the **`---`** line). The content that you write below the **`---`** line will be the content shown when the card is expanded in a modal view. For example: ```md -This is the default HTTP trigger template for Rust. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default HTTP trigger template for Rust. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [HTTP Components](../../spin/rust-components#http-components) +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/rust-components#http-components) ``` ### Valid Metadata diff --git a/content/api/hub/plugin_js2wasm.md b/content/api/hub/plugin_js2wasm.md index a6c04f5a7..43acdb806 100644 --- a/content/api/hub/plugin_js2wasm.md +++ b/content/api/hub/plugin_js2wasm.md @@ -18,7 +18,7 @@ keywords = "plugins, packaging plugins, javascript, typescript" --- -This is an SDK for building Spin apps using JavaScript (and TypeScript). It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is an SDK for building Spin apps using JavaScript (and TypeScript). It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). ## Installation @@ -26,4 +26,4 @@ This is an SDK for building Spin apps using JavaScript (and TypeScript). It inst spin plugins install js2wasm ``` -This guide walks you through how to use it: [HTTP Components](../../spin/javascript-components) \ No newline at end of file +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/javascript-components) \ No newline at end of file diff --git a/content/api/hub/sample_code_pls.md b/content/api/hub/sample_code_pls.md index 21ce895db..bd2150d64 100644 --- a/content/api/hub/sample_code_pls.md +++ b/content/api/hub/sample_code_pls.md @@ -23,6 +23,6 @@ Checkout the [app here](https://code-pls.fermyon.app/) Get started with `spin build`, `spin up` and `spin deploy`. -[See the AI capabilities using Fermyon serverless AI!](https://developer.fermyon.com/spin/v2/serverless-ai-hello-world.md) +[See the AI capabilities using Fermyon serverless AI!](https://spinframework.dev/v2/serverless-ai-hello-world.md) diff --git a/content/api/hub/sample_http_auth_middleware.md b/content/api/hub/sample_http_auth_middleware.md index a4f88a30d..862349d4f 100644 --- a/content/api/hub/sample_http_auth_middleware.md +++ b/content/api/hub/sample_http_auth_middleware.md @@ -36,7 +36,7 @@ cargo install --git https://github.com/bytecodealliance/cargo-component cargo-co cargo install --git https://github.com/dicej/wasm-tools --branch wasm-compose-resource-imports wasm-tools --locked ``` -* Install latest [Spin](../../spin/v2/install) +* Install latest [Spin](https://spinframework.dev/v2/install) * Create an OAuth App in your [GitHub Developer Settings](https://github.com/settings/developers). * Set the callback URL to `http://127.0.0.1:3000/login/callback`. * Accept defaults and input dummy values for the rest of the fields. diff --git a/content/api/hub/sample_kv_in_python.md b/content/api/hub/sample_kv_in_python.md index 8ef2a5e67..2f7ac2305 100644 --- a/content/api/hub/sample_kv_in_python.md +++ b/content/api/hub/sample_kv_in_python.md @@ -18,4 +18,4 @@ keywords = "python, JSON, key-value" --- -Simple example of how to use Spin's built-in [key-value store](../../spin/v2/key-value-store-tutorial) to store and retrieve JSON documents in Python. \ No newline at end of file +Simple example of how to use Spin's built-in [key-value store](https://spinframework.dev/v2/key-value-store-tutorial) to store and retrieve JSON documents in Python. \ No newline at end of file diff --git a/content/api/hub/sample_kv_in_typescript.md b/content/api/hub/sample_kv_in_typescript.md index b502a469e..ff551dfe1 100644 --- a/content/api/hub/sample_kv_in_typescript.md +++ b/content/api/hub/sample_kv_in_typescript.md @@ -18,7 +18,7 @@ keywords = "typescript, javascript, key-value" --- -This sample shows how to use all of the different [Key/Value functions](../../spin/kv-store-api-guide) in TypeScript, including how to decode results, trap errors in a `try/catch`, and work with JSON. +This sample shows how to use all of the different [Key/Value functions](https://spinframework.dev/kv-store-api-guide) in TypeScript, including how to decode results, trap errors in a `try/catch`, and work with JSON. This will help you get started with KV storage either locally using `spin up` or in Fermyon Cloud using `spin deploy`. diff --git a/content/api/hub/sample_ollama.md b/content/api/hub/sample_ollama.md index d8889716c..cb4ffbddf 100644 --- a/content/api/hub/sample_ollama.md +++ b/content/api/hub/sample_ollama.md @@ -21,7 +21,7 @@ keywords = "rust, ollama, llm, ai" This sample demonstrates how spin can be used to implement the [Ollama api](https://github.com/jmorganca/ollama/blob/main/docs/api.md), which when deployed can be used as any other Ollama instance. LLM orchestration frameworks like LangChain and semantic kernel can use this instance as a Ollama backend. ## Quick Start -- [Install spin](../../spin/v2/install) +- [Install spin](https://spinframework.dev/v2/install) - login to fermeyon cloud ``` spin login diff --git a/content/api/hub/sample_openaichat_ts.md b/content/api/hub/sample_openaichat_ts.md index a3bacf89b..95b4fd76a 100644 --- a/content/api/hub/sample_openaichat_ts.md +++ b/content/api/hub/sample_openaichat_ts.md @@ -67,7 +67,7 @@ $ curl -d "Will I get a pet tortoise?" http://127.0.0.1:3000/question The HTTP request is handled by the `handleRequest` function. Following is an overview of the process flow: - Retreive the question by decoding the response body -- Fetch the OpenAPI Key from the Spin Config [Reference](../../spin/dynamic-configuration#custom-config-providers) +- Fetch the OpenAPI Key from the Spin Config [Reference](https://spinframework.dev/dynamic-configuration#custom-config-providers) - Structure the request to be sent to OpenAI - Decode the response - Structure and return the response to the client. @@ -76,8 +76,8 @@ Please refer to the code for the details of the implementation. ## References -- [Sending Outbound HTTP Requests](../../spin/javascript-components#sending-outbound-http-requests) +- [Sending Outbound HTTP Requests](https://spinframework.dev/javascript-components#sending-outbound-http-requests) -- [Spin Config](../../spin/dynamic-configuration#custom-config-providers) +- [Spin Config](https://spinframework.dev/dynamic-configuration#custom-config-providers) - [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create) diff --git a/content/api/hub/sample_router.md b/content/api/hub/sample_router.md index dcf6492ae..b015e6881 100644 --- a/content/api/hub/sample_router.md +++ b/content/api/hub/sample_router.md @@ -18,9 +18,9 @@ keywords = "router, python" --- -This project showcases how to do internal HTTP routing in a Spin Python application. It is similar to [the Spin JS router](../../spin/v2/javascript-components#routing-in-a-component) as well as the Django router. +This project showcases how to do internal HTTP routing in a Spin Python application. It is similar to [the Spin JS router](https://spinframework.dev/v2/javascript-components#routing-in-a-component) as well as the Django router. -If you are interested in external routing (where the routing table is declared in the spin.toml), the [Application Structure guide](../../spin/v2/spin-application-structure) covers this. +If you are interested in external routing (where the routing table is declared in the spin.toml), the [Application Structure guide](https://spinframework.dev/v2/spin-application-structure) covers this. This uses the absolutely fantastic [http_router](https://pypi.org/project/http-router/) project. You will likely want to reference the API docs: * https://github.com/klen/http-router. diff --git a/content/api/hub/sample_ts_router_post.md b/content/api/hub/sample_ts_router_post.md index 11447aedc..914f19440 100644 --- a/content/api/hub/sample_ts_router_post.md +++ b/content/api/hub/sample_ts_router_post.md @@ -18,7 +18,7 @@ keywords = "typescript, javascript, router" --- -This shows one technique for handling POST data using the `Router` object [built into the JS/TS SDK](../../spin/v2/javascript-components) for Spin. +This shows one technique for handling POST data using the `Router` object [built into the JS/TS SDK](https://spinframework.dev/v2/javascript-components) for Spin. This example illustrates how to pass the HTTP body from Spin's SDK all the way to your end function without needing to use middleware. diff --git a/content/api/hub/template_http_empty.md b/content/api/hub/template_http_empty.md index 636e03167..ffec6ccdf 100644 --- a/content/api/hub/template_http_empty.md +++ b/content/api/hub/template_http_empty.md @@ -19,6 +19,6 @@ keywords = "web app, http, api, starter" --- -This template creates an HTTP application with no components. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This template creates an HTTP application with no components. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -Use this template when you expect to [add](../../spin/writing-apps#adding-a-new-component-to-an-application) multiple components to an application, to help you establish an even directory structure. +Use this template when you expect to [add](https://spinframework.dev/writing-apps#adding-a-new-component-to-an-application) multiple components to an application, to help you establish an even directory structure. diff --git a/content/api/hub/template_http_go.md b/content/api/hub/template_http_go.md index fb9919665..94fc84b70 100644 --- a/content/api/hub/template_http_go.md +++ b/content/api/hub/template_http_go.md @@ -20,6 +20,6 @@ keywords = "web app, http, api" --- -This is the default HTTP trigger template for Go. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default HTTP trigger template for Go. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [HTTP Components](../../spin/go-components#http-components) \ No newline at end of file +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/go-components#http-components) \ No newline at end of file diff --git a/content/api/hub/template_http_js.md b/content/api/hub/template_http_js.md index d07057912..6adbe5189 100644 --- a/content/api/hub/template_http_js.md +++ b/content/api/hub/template_http_js.md @@ -20,6 +20,6 @@ keywords = "web app, http, api" --- -This is the default HTTP trigger template for JavaScript. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default HTTP trigger template for JavaScript. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [HTTP Components](../../spin/javascript-components#http-components) \ No newline at end of file +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/javascript-components#http-components) \ No newline at end of file diff --git a/content/api/hub/template_http_python.md b/content/api/hub/template_http_python.md index cc60b7c5d..264cbf8f3 100644 --- a/content/api/hub/template_http_python.md +++ b/content/api/hub/template_http_python.md @@ -30,6 +30,6 @@ python3 --version If you do not have Python 3.10 or later, you can install it by following the instructions [here](https://www.python.org/downloads/). -This is the default HTTP trigger template for Python. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default HTTP trigger template for Python. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [Structure of a Python Component](../../spin/python-components#structure-of-a-python-component) \ No newline at end of file +This guide walks you through how to use it: [Structure of a Python Component](https://spinframework.dev/python-components#structure-of-a-python-component) \ No newline at end of file diff --git a/content/api/hub/template_http_rust.md b/content/api/hub/template_http_rust.md index 3856ebff5..ebdc51bff 100644 --- a/content/api/hub/template_http_rust.md +++ b/content/api/hub/template_http_rust.md @@ -20,6 +20,6 @@ keywords = "web app, http, api" --- -This is the default HTTP trigger template for Rust. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default HTTP trigger template for Rust. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [HTTP Components](../../spin/rust-components#http-components) \ No newline at end of file +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/rust-components#http-components) \ No newline at end of file diff --git a/content/api/hub/template_http_ts.md b/content/api/hub/template_http_ts.md index bb54b98ed..0bc339fba 100644 --- a/content/api/hub/template_http_ts.md +++ b/content/api/hub/template_http_ts.md @@ -20,6 +20,6 @@ keywords = "web app, http, api" --- -This is the default HTTP trigger template for TypeScript. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default HTTP trigger template for TypeScript. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [HTTP Components](../../spin/javascript-components#http-components) \ No newline at end of file +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/javascript-components#http-components) \ No newline at end of file diff --git a/content/api/hub/template_kv_explorer.md b/content/api/hub/template_kv_explorer.md index fccef9d44..170852bd3 100644 --- a/content/api/hub/template_kv_explorer.md +++ b/content/api/hub/template_kv_explorer.md @@ -22,7 +22,7 @@ keywords = "key-value, kv, explorer" This template enables managing the key value pairs set in any key value store linked to an application. -To keep the contents of your key value store secure, the explorer expects the credentials to access the UI and the API to be stored in the configuration store as variables. Values can be set locally using the [variables provider](../../spin/v2/dynamic-configuration#application-variables-runtime-configuration) or you can skip checking for the credentials on every request by passing the `SPIN_APP_KV_SKIP_AUTH` environment variable. When deploying to cloud, set the `kv_explorer_user` and `kv_explorer_password` variables using the `--variable` flag. These credentials can then be updated at any time using `spin cloud variables set`. +To keep the contents of your key value store secure, the explorer expects the credentials to access the UI and the API to be stored in the configuration store as variables. Values can be set locally using the [variables provider](https://spinframework.dev/v2/dynamic-configuration#application-variables-runtime-configuration) or you can skip checking for the credentials on every request by passing the `SPIN_APP_KV_SKIP_AUTH` environment variable. When deploying to cloud, set the `kv_explorer_user` and `kv_explorer_password` variables using the `--variable` flag. These credentials can then be updated at any time using `spin cloud variables set`. Visit the [GitHub repo](https://github.com/fermyon/spin-kv-explorer) for complete configuration instructions. diff --git a/content/api/hub/template_nextjs.md b/content/api/hub/template_nextjs.md index 461244cb2..b6b4a38ed 100644 --- a/content/api/hub/template_nextjs.md +++ b/content/api/hub/template_nextjs.md @@ -22,4 +22,4 @@ keywords = "react, next.js, js, javascript, typescript" This is a template for building and statically exporting your Next.js 13 application and running it on Spin. -This guide walks you through how to use it: [HTTP Components](../../spin/javascript-components#http-components) \ No newline at end of file +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/javascript-components#http-components) \ No newline at end of file diff --git a/content/api/hub/template_qwik_frontend.md b/content/api/hub/template_qwik_frontend.md index 002f91f08..c0d23d260 100644 --- a/content/api/hub/template_qwik_frontend.md +++ b/content/api/hub/template_qwik_frontend.md @@ -24,4 +24,4 @@ This is a template for building and statically exporting your Qwik Frontend appl Demo: [https://qwik.fermyon.app/](https://qwik.fermyon.app/) -This guide walks you through how to use it: [HTTP Components](../../spin/javascript-components#http-components) +This guide walks you through how to use it: [HTTP Components](https://spinframework.dev/javascript-components#http-components) diff --git a/content/api/hub/template_redis_go.md b/content/api/hub/template_redis_go.md index e0bb95d4d..843327abb 100644 --- a/content/api/hub/template_redis_go.md +++ b/content/api/hub/template_redis_go.md @@ -20,6 +20,6 @@ keywords = "web app, redis" --- -This is the default Redis pub-sub trigger template for Go. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default Redis pub-sub trigger template for Go. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [Redis Components](../../spin/go-components#redis-components) \ No newline at end of file +This guide walks you through how to use it: [Redis Components](https://spinframework.dev/go-components#redis-components) \ No newline at end of file diff --git a/content/api/hub/template_redis_rust.md b/content/api/hub/template_redis_rust.md index 7d1c16435..9c7fbc4f4 100644 --- a/content/api/hub/template_redis_rust.md +++ b/content/api/hub/template_redis_rust.md @@ -20,6 +20,6 @@ keywords = "web app, redis" --- -This is the default Redis pub-sub trigger template for Rust. It installs by default with the [Spin install script](../../spin/install#installing-spin). +This is the default Redis pub-sub trigger template for Rust. It installs by default with the [Spin install script](https://spinframework.dev/install#installing-spin). -This guide walks you through how to use it: [Redis Components](../../spin/rust-components#redis-components) \ No newline at end of file +This guide walks you through how to use it: [Redis Components](https://spinframework.dev/rust-components#redis-components) \ No newline at end of file diff --git a/content/bartholomew/contributing-bartholomew.md b/content/bartholomew/contributing-bartholomew.md index 5080867ef..f81dcc8c7 100644 --- a/content/bartholomew/contributing-bartholomew.md +++ b/content/bartholomew/contributing-bartholomew.md @@ -271,14 +271,14 @@ The output from the above command will be similar to the following (depending on To run Bartholomew, you will need a Spin-capable runtime. -For Spin, follow [the Spin quickstart guide](/spin/quickstart) which details how to either: +For Spin, follow [the Spin quickstart guide](https://spinframework.dev/quickstart) which details how to either: - download the latest Spin binary release, - clone and install Spin using cargo, or - clone and build Spin from source. ## The Relationship Between Bartholomew and the Spin Fileserver -Bartholomew uses an external file server called [Spin-Fileserver](https://github.com/fermyon/spin-fileserver). This file server facilitates the presentation of files to the end users. For example, whilst the web page contents (HTML) are generated dynamically upon request, image elements in that HTML page source can point to images that are stored on the host server. The Spin file server ensures that these static images are correctly served to the client's web browser (as per the HTML's requirements.) +Bartholomew uses an external file server called [Spin-Fileserver](https://github.com/spinframework/spin-fileserver). This file server facilitates the presentation of files to the end users. For example, whilst the web page contents (HTML) are generated dynamically upon request, image elements in that HTML page source can point to images that are stored on the host server. The Spin file server ensures that these static images are correctly served to the client's web browser (as per the HTML's requirements.) Please build the spin-fileserver and then copy the resulting `spin_static_fs.wasm` file into Bartholomew's `modules/` directory. This will ensure that you are running the latest release of the spin-fileserver. diff --git a/content/bartholomew/contributing-docs.md b/content/bartholomew/contributing-docs.md index bc823178f..7edc33e41 100644 --- a/content/bartholomew/contributing-docs.md +++ b/content/bartholomew/contributing-docs.md @@ -1,7 +1,7 @@ title = "Contributing to Docs" template = "bartholomew_main" date = "2022-01-01T00:00:01Z" -body_source = "/spin/v1/contributing-docs" +body_source = "/common/contributing-docs" [extra] url = "https://github.com/fermyon/developer/blob/main/content/bartholomew/contributing-docs.md" keywords = "contribute contributing" diff --git a/content/bartholomew/index.md b/content/bartholomew/index.md index bc2dff748..195a2eeb4 100644 --- a/content/bartholomew/index.md +++ b/content/bartholomew/index.md @@ -10,7 +10,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/bartholomew/index. - [Taking Bartholomew for a Spin](#taking-bartholomew-for-a-spin) Bartholomew is a simple CMS-like (Content Management System) tool for managing a -website. It is compiled to WebAssembly, and can run in any [Spin](/spin) +website. It is compiled to WebAssembly, and can run in any [Spin](https://spinframework.dev) environment. At a glance, with Bartholomew you can: @@ -20,7 +20,7 @@ simple [TOML](https://toml.io/en/) header. - Create custom page templates using the popular [Handlebars](https://handlebarsjs.com/) templates. - Build custom functions using [the Rhai scripting language](https://rhai.rs/). -- Serve files using [the Spin static file server](https://github.com/fermyon/spin-fileserver). +- Serve files using [the Spin static file server](https://github.com/spinframework/spin-fileserver). ## Overview @@ -29,7 +29,7 @@ one you might find in AWS Lambda or Azure Functions. The CMS is only running whe it needs to handle incoming requests, reducing the load on the servers running it. -Bartholomew is a [Spin](/spin) component, and +Bartholomew is a [Spin](https://spinframework.dev) component, and websites built with Bartholomew are Spin applications that can run in any environment that is capable of running Spin. At Fermyon, we run all of our websites using Bartholomew and Spin, on our [Fermyon Platform, running on Nomad](https://www.fermyon.com/blog/spin-nomad). diff --git a/content/bartholomew/markdown.md b/content/bartholomew/markdown.md index 5a46e84e9..c4167328a 100644 --- a/content/bartholomew/markdown.md +++ b/content/bartholomew/markdown.md @@ -76,7 +76,7 @@ key = "your custom name value pairs go hear, but values MUST be strings" ### Markdown Body Markdown support includes all the usual stuff plus fenced codeblocks. Image links are -supported, but you need to use the external [fileserver](https://github.com/fermyon/spin-fileserver) +supported, but you need to use the external [fileserver](https://github.com/spinframework/spin-fileserver) library to display the images. If you are using your deployment of Spin and Bartholomew, you can [read more about how to install the fileserver](/bartholomew/contributing-bartholomew) from source. The last line of the example above is very important. The `---` tells Bartholomew that the head is done, and the body is coming up. diff --git a/content/bartholomew/quickstart.md b/content/bartholomew/quickstart.md index ca8feeb51..5bc14c797 100644 --- a/content/bartholomew/quickstart.md +++ b/content/bartholomew/quickstart.md @@ -23,14 +23,14 @@ This is a quickstart example of using Spin to deploy a Bartholomew CMS instance, ## Getting the `spin` Binary -For Spin, follow [the Spin quickstart guide](/spin/quickstart) which details how to either: +For Spin, follow [the Spin quickstart guide](https://spinframework.dev/quickstart) which details how to either: - download the latest Spin binary release, - clone and build Spin using cargo, or - clone and build Spin from source. ## Templates -This quickstart method uses a Bartholomew site template. So while we do require `spin` (as per the details above) everything else we need (to launch our Bartholomew CMS website) is packaged up in the Bartholomew site template. Including the `bartholomew.wasm` and the `spin_static_fs.wasm` files which take care of Bartholomew's business logic and [Spin's file server](https://github.com/fermyon/spin-fileserver) needs, respectively. We will start working with the template in the next section. +This quickstart method uses a Bartholomew site template. So while we do require `spin` (as per the details above) everything else we need (to launch our Bartholomew CMS website) is packaged up in the Bartholomew site template. Including the `bartholomew.wasm` and the `spin_static_fs.wasm` files which take care of Bartholomew's business logic and [Spin's file server](https://github.com/spinframework/spin-fileserver) needs, respectively. We will start working with the template in the next section. ## Use the Bartholomew Site Template diff --git a/content/cloud/changelog/cloud-config.md b/content/cloud/changelog/cloud-config.md index 20dc2b2aa..e8216d42a 100644 --- a/content/cloud/changelog/cloud-config.md +++ b/content/cloud/changelog/cloud-config.md @@ -15,6 +15,6 @@ Now, when your application is deployed to Fermyon Cloud you can set and update v References: -- [Dynamic and Runtime Application Configuration](../../spin/dynamic-configuration) +- [Dynamic and Runtime Application Configuration](https://spinframework.dev/dynamic-configuration) - [Configuring Spin Application Variables and Secrets Tutorial](../variables) - [cloud-plugin](https://github.com/fermyon/cloud-plugin) \ No newline at end of file diff --git a/content/cloud/changelog/cloud-key-value.md b/content/cloud/changelog/cloud-key-value.md index dcff3d302..cadb167a8 100644 --- a/content/cloud/changelog/cloud-key-value.md +++ b/content/cloud/changelog/cloud-key-value.md @@ -8,7 +8,7 @@ type= "changelog_post" --- -Fermyon Cloud now supports [Key Value Store](/spin/kv-store-api-guide). While Spin applications are well suited for event-driven, stateless workloads, these serverless workloads often rely on external services to persist state beyond the lifespan of a single request. With the introduction of [Fermyon Cloud Key Value Store](https://www.fermyon.com/blog/introducing-fermyon-cloud-key-value-store), you can now persist non-relational data in a key/value store that is always available for your serverless application (within milliseconds and without cold starts). No infrastructure provisioning or maintenance is required. Developers can now deploy their Fermyon Cloud Key Value Store applications simply by running `spin cloud deploy`. +Fermyon Cloud now supports [Key Value Store](https://spinframework.dev/kv-store-api-guide). While Spin applications are well suited for event-driven, stateless workloads, these serverless workloads often rely on external services to persist state beyond the lifespan of a single request. With the introduction of [Fermyon Cloud Key Value Store](https://www.fermyon.com/blog/introducing-fermyon-cloud-key-value-store), you can now persist non-relational data in a key/value store that is always available for your serverless application (within milliseconds and without cold starts). No infrastructure provisioning or maintenance is required. Developers can now deploy their Fermyon Cloud Key Value Store applications simply by running `spin cloud deploy`. Key Value Store @@ -16,7 +16,7 @@ Fermyon Cloud now supports [Key Value Store](/spin/kv-store-api-guide). While Sp References: -- [Spin Key Value API Guide](/spin/kv-store-api-guide) -- [Spin Key Value Tutorial](/spin/key-value-store-tutorial) +- [Spin Key Value API Guide](https://spinframework.dev/kv-store-api-guide) +- [Spin Key Value Tutorial](https://spinframework.dev/key-value-store-tutorial) - [Introducing Fermyon Cloud Key Store](https://www.fermyon.com/blog/introducing-fermyon-cloud-key-value-store) - [Cloud Limitations](/cloud/faq) \ No newline at end of file diff --git a/content/cloud/changelog/cloud-noops-sql-db.md b/content/cloud/changelog/cloud-noops-sql-db.md index dae9a58d3..1c3bdebe4 100644 --- a/content/cloud/changelog/cloud-noops-sql-db.md +++ b/content/cloud/changelog/cloud-noops-sql-db.md @@ -17,4 +17,4 @@ References: - [SQLite Database Documentation](/cloud/noops-sql-db) - [SQLite Database Blog Post](https://www.fermyon.com/blog/announcing-noops-sql-db) - [Discord Channel](https://www.fermyon.com/discord) -- [Spin's SQLite Database Storage API](/spin/sqlite-api-guide.md) +- [Spin's SQLite Database Storage API](https://spinframework.dev/sqlite-api-guide.md) diff --git a/content/cloud/changelog/request-metrics-in-cloud.md b/content/cloud/changelog/request-metrics-in-cloud.md index eb6f47af1..ca5f86a87 100644 --- a/content/cloud/changelog/request-metrics-in-cloud.md +++ b/content/cloud/changelog/request-metrics-in-cloud.md @@ -7,7 +7,7 @@ tags = ["observability"] type= "changelog_post" --- -You can now see your Spin application’s request count over time in the Fermyon Cloud User Interface (UI). Request count is defined as the number of times your Spin application’s [HTTP trigger](/spin/http-trigger) has been called while running on Fermyon Cloud. To view an Spin application’s request count data over time, log into Fermyon Cloud and click on the application of interest. Feel free to reach out to us on [Discord](https://discord.gg/AAFNfS7NGf) and let us know what you think. +You can now see your Spin application’s request count over time in the Fermyon Cloud User Interface (UI). Request count is defined as the number of times your Spin application’s [HTTP trigger](https://spinframework.dev/http-trigger) has been called while running on Fermyon Cloud. To view an Spin application’s request count data over time, log into Fermyon Cloud and click on the application of interest. Feel free to reach out to us on [Discord](https://discord.gg/AAFNfS7NGf) and let us know what you think. Demo of request count metrics in Fermyon Cloud. diff --git a/content/cloud/changelog/serverless-ai-open-beta.md b/content/cloud/changelog/serverless-ai-open-beta.md index 2f41637c0..717618ee7 100644 --- a/content/cloud/changelog/serverless-ai-open-beta.md +++ b/content/cloud/changelog/serverless-ai-open-beta.md @@ -20,6 +20,6 @@ To review quotas and FAQs, please visit [Fermyon Cloud FAQ documentation.](../.. References: -- [Serverless AI API Guide](../../spin/v2/serverless-ai-api-guide) -- [Serverless AI Tutorial](../../spin/v2/serverless-ai-hello-world.md) +- [Serverless AI API Guide](https://spinframework.dev/v2/serverless-ai-api-guide) +- [Serverless AI Tutorial](https://spinframework.dev/v2/serverless-ai-hello-world.md) - [`spin cloud GPU` plugin](../../api/hub/preview/plugin_spin_cloud_gpu) \ No newline at end of file diff --git a/content/cloud/changelog/serverless-ai.md b/content/cloud/changelog/serverless-ai.md index 724e3671e..c86e16b97 100644 --- a/content/cloud/changelog/serverless-ai.md +++ b/content/cloud/changelog/serverless-ai.md @@ -10,7 +10,7 @@ image = "/static/changelog/fermyon-severless-ai-twitter-card.jpg" --- -We're thrilled to announce that [Fermyon Serverless AI](/cloud/serverless-ai) is in private beta. Developers can now [use Spin to perform AI inferencing and embedding](/spin/ai-sentiment-analysis-api-tutorial) from within serverless Spin applications (that are either running locally or deployed to Fermyon Cloud). You can sign up for the private beta using [this short form](https://fibsu0jcu2g.typeform.com/to/mNzgXRvB). +We're thrilled to announce that [Fermyon Serverless AI](/cloud/serverless-ai) is in private beta. Developers can now [use Spin to perform AI inferencing and embedding](https://spinframework.dev/ai-sentiment-analysis-api-tutorial) from within serverless Spin applications (that are either running locally or deployed to Fermyon Cloud). You can sign up for the private beta using [this short form](https://fibsu0jcu2g.typeform.com/to/mNzgXRvB). Custom Fermyon Subdomains @@ -21,4 +21,4 @@ References: - [Fermyon Serverless AI (Private Beta) Documentation](/cloud/serverless-ai.md) - [Serverless AI (Private Beta) Blog Post](https://www.fermyon.com/blog/introducing-fermyon-serverless-ai) - [Discord Channel](https://www.fermyon.com/discord) -- [Spin's Serverless API](/spin/serverless-ai-api-guide.md) +- [Spin's Serverless API](https://spinframework.dev/serverless-ai-api-guide.md) diff --git a/content/cloud/changelog/spin-cloud-v0-5-0.md b/content/cloud/changelog/spin-cloud-v0-5-0.md index 92403581a..132f0c787 100644 --- a/content/cloud/changelog/spin-cloud-v0-5-0.md +++ b/content/cloud/changelog/spin-cloud-v0-5-0.md @@ -14,7 +14,7 @@ image = "/static/image/changelog/spin-cloud-0.5.0.jpg" We’re excited to announce the v0.5.0 release of the `spin cloud` plugin. Some notable improvements over the last minor update include: -- Support for component model on Fermyon Cloud! Simply use [Spin 2.0’s application manifest](../../spin/v2/manifest-reference) and run `spin cloud deploy` to deploy your component model enlightened Spin application to Fermyon Cloud. You can learn more about the many benefits of the component model (polyglot, performance, & portability, to name a few) with [our latest blog post](https://www.fermyon.com/blog/index). +- Support for component model on Fermyon Cloud! Simply use [Spin 2.0’s application manifest](https://spinframework.dev/v2/manifest-reference) and run `spin cloud deploy` to deploy your component model enlightened Spin application to Fermyon Cloud. You can learn more about the many benefits of the component model (polyglot, performance, & portability, to name a few) with [our latest blog post](https://www.fermyon.com/blog/index). - `spin cloud logs` allows you to stream logs produced by your Spin application of choice running on Fermyon Cloud. Also, please note, there is a slight rewording in the help commands of `spin cloud`'s help text: @@ -24,5 +24,5 @@ Also, please note, there is a slight rewording in the help commands of `spin clo **References** - [Spin 2.0 blog post](https://www.fermyon.com/blog/index) -- [Spin 2.0 quickstart guide](../../spin/v2/quickstart) +- [Spin 2.0 quickstart guide](https://spinframework.dev/v2/quickstart) - [Spin Cloud Plugin Reference Documentation](/cloud/cloud-command-reference) diff --git a/content/cloud/changelog/spin-cloud-v0-5-1.md b/content/cloud/changelog/spin-cloud-v0-5-1.md index 8844396bb..675e6f40d 100644 --- a/content/cloud/changelog/spin-cloud-v0-5-1.md +++ b/content/cloud/changelog/spin-cloud-v0-5-1.md @@ -21,6 +21,6 @@ If you encounter any issues or have questions during the upgrade process, please **References** - [Spin 2.0 blog post](https://www.fermyon.com/blog/index) -- [Spin 2.0 quickstart guide](../../spin/v2/quickstart) +- [Spin 2.0 quickstart guide](https://spinframework.dev/v2/quickstart) - [Spin Cloud Plugin Reference Documentation](/cloud/cloud-command-reference) -- [Using Spin to Make HTTP Requests](/spin/v2/http-outbound) +- [Using Spin to Make HTTP Requests](https://spinframework.dev/v2/http-outbound) diff --git a/content/cloud/cli-reference.md b/content/cloud/cli-reference.md deleted file mode 100644 index 4a4109666..000000000 --- a/content/cloud/cli-reference.md +++ /dev/null @@ -1,10 +0,0 @@ -title = "Spin Command Line Interface (CLI) Reference" -template = "cloud_main" -date = "2022-01-01T00:00:01Z" -enable_shortcodes = true -body_source = "/spin/v1/cli-reference" - -[extra] -url = "https://github.com/fermyon/developer/blob/main/content/cloud/cli-reference.md" - ---- diff --git a/content/cloud/cloud-command-reference.md b/content/cloud/cloud-command-reference.md index 10cfa4841..001a83fa1 100644 --- a/content/cloud/cloud-command-reference.md +++ b/content/cloud/cloud-command-reference.md @@ -45,7 +45,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/cloud-comman ## Spin Cloud Command -Fermyon provides a [`cloud` plugin](https://github.com/fermyon/cloud-plugin) for the [Spin CLI](./cli-reference.md) for you to manage Spin applications in Fermyon Cloud. This page documents the `spin cloud` command. Specifically, all of the available options and subcommands. For more information on subcommand stability, see the [subcommands stability table](#subcommand-stability-table). You can reproduce the Spin Cloud command documentation on your machine by using the `--help` flag. For example: +Fermyon provides a [`cloud` plugin](https://github.com/fermyon/cloud-plugin) for the [Spin CLI](https://spinframework.dev) for you to manage Spin applications in Fermyon Cloud. This page documents the `spin cloud` command. Specifically, all of the available options and subcommands. For more information on subcommand stability, see the [subcommands stability table](#subcommand-stability-table). You can reproduce the Spin Cloud command documentation on your machine by using the `--help` flag. For example: ## spin cloud diff --git a/content/cloud/contributing-docs.md b/content/cloud/contributing-docs.md index 9438610e4..19df248d5 100644 --- a/content/cloud/contributing-docs.md +++ b/content/cloud/contributing-docs.md @@ -1,7 +1,7 @@ title = "Contributing to Docs" template = "cloud_main" date = "2022-01-01T00:00:01Z" -body_source = "/spin/v1/contributing-docs" +body_source = "/common/contributing-docs" [extra] url = "https://github.com/fermyon/developer/blob/main/content/cloud/contributing-docs.md" diff --git a/content/cloud/data-postgres.md b/content/cloud/data-postgres.md index 95a87cc4a..0dc460f68 100644 --- a/content/cloud/data-postgres.md +++ b/content/cloud/data-postgres.md @@ -24,7 +24,7 @@ First, you need to have Spin installed on your computer. Please use the official ## Using Spin Application Templates -The Spin CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](/cloud/cli-reference#templates). The template we are interested in, for this tutorial, is the experimental `http-csharp` template. We can go ahead and install it using the following command: +The Spin CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](https://spinframework.dev/managing-templates). The template we are interested in, for this tutorial, is the experimental `http-csharp` template. We can go ahead and install it using the following command: @@ -50,7 +50,7 @@ Installed 1 template(s) ## Creating Our New Spin Application -The official Spin CLI documentation also has instructions on how to [create a new Spin application](/cloud/cli-reference#new), from an existing template. Using the docs as a reference, we can perform the following: +The official Spin CLI documentation also has instructions on how to [create a new Spin application](https://spinframework.dev/quickstart), from an existing template. Using the docs as a reference, we can perform the following: diff --git a/content/cloud/data-redis.md b/content/cloud/data-redis.md index 02e2bbd8c..85aef03f0 100644 --- a/content/cloud/data-redis.md +++ b/content/cloud/data-redis.md @@ -27,7 +27,7 @@ First, you need to have Spin installed on your computer. Please use the official ## Using Spin Application Templates -The Spin CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](/cloud/cli-reference#templates). For example: +The Spin CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](https://spinframework.dev/managing-templates). For example: @@ -59,7 +59,7 @@ The template we are interested in is `http-rust`. ## Creating Our New Spin Application -The official Spin CLI documentation also has instructions on how to [create a new Spin application](/cloud/cli-reference#new). Let's go ahead and create a new `http-rust` application: +The official Spin CLI documentation also has instructions on how to [create a new Spin application](https://spinframework.dev/quickstart). Let's go ahead and create a new `http-rust` application: diff --git a/content/cloud/deploy.md b/content/cloud/deploy.md index 8b14c1b32..ca121f761 100644 --- a/content/cloud/deploy.md +++ b/content/cloud/deploy.md @@ -11,7 +11,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/deploy.md" - [Deploy Your Application](#deploy-your-application) - [Next Steps](#next-steps) -This article will guide you through deploying a Spin Application with the Fermyon Cloud. You can deploy your [Spin App](/spin) or [Bartholomew](https://github.com/fermyon/bartholomew) site in just a few steps. +This article will guide you through deploying a Spin Application with the Fermyon Cloud. You can deploy your [Spin App](https://spinframework.dev) or [Bartholomew](https://github.com/fermyon/bartholomew) site in just a few steps. ## Prerequisites - Install the Spin CLI diff --git a/content/cloud/develop.md b/content/cloud/develop.md index 61d257b1f..19055c14c 100644 --- a/content/cloud/develop.md +++ b/content/cloud/develop.md @@ -15,7 +15,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/develop.md" - [Run the Application](#run-the-application) - [Next Steps](#next-steps) -This article briefly describes how to create a new Spin application. For a more thorough guide to developing Spin applications, take a look [here](/spin/writing-apps). +This article briefly describes how to create a new Spin application. For a more thorough guide to developing Spin applications, take a look [here](https://spinframework.dev/writing-apps). ## Prerequisites - Install the Spin CLI @@ -192,7 +192,7 @@ You'll need the `wasm32-wasi` target for Rust: $ rustup target add wasm32-wasi ``` -[Learn more in the language guide.](/spin/rust-components) +[Learn more in the language guide.](https://spinframework.dev/rust-components) {{ blockEnd }} @@ -207,7 +207,7 @@ $ spin plugins update $ spin plugins install js2wasm --yes ``` -[Learn more in the language guide.](/spin/javascript-components) +[Learn more in the language guide.](https://spinframework.dev/javascript-components) {{ blockEnd }} @@ -292,7 +292,7 @@ From here the app is ready to build and run: $ spin build --up ``` -[Learn more in the language guide.](/spin/python-components) +[Learn more in the language guide.](https://spinframework.dev/python-components) {{ blockEnd }} @@ -300,7 +300,7 @@ $ spin build --up You'll need the TinyGo compiler, as the standard Go compiler does not yet support the WASI standard. See the [TinyGo installation guide](https://tinygo.org/getting-started/install/). -[Learn more in the language guide.](/spin/go-components) +[Learn more in the language guide.](https://spinframework.dev/go-components) {{ blockEnd }} @@ -637,5 +637,5 @@ Hello, Fermyon ## Next Steps - Learn how to [deploy an application](deploy) -- To learn more about how to develop Spin applications, head over to the [Spin documentation](/spin) +- To learn more about how to develop Spin applications, head over to the [Spin documentation](https://spinframework.dev) - Find known issues and file new ones with this [GitHub repository](https://github.com/fermyon/feedback) diff --git a/content/cloud/faq.md b/content/cloud/faq.md index f90d19799..f8107a838 100644 --- a/content/cloud/faq.md +++ b/content/cloud/faq.md @@ -75,34 +75,34 @@ Fermyon Cloud supports Spin CLI v0.6.0 or newer. That being said, there are cert | Feature | SDK Supported? | |-----|-----| | **Triggers** | -| [HTTP](/spin/http-trigger) | Supported | -| [Redis](/spin/redis-trigger) | Not supported | +| [HTTP](https://spinframework.dev/http-trigger) | Supported | +| [Redis](https://spinframework.dev/redis-trigger) | Not supported | | **APIs** | -| [Outbound HTTP](/spin/rust-components.md#sending-outbound-http-requests) | Supported | -| [Configuration Variables](/spin/variables) | Supported | -| [Key Value Storage](/spin/kv-store-api-guide) | Supported | -| [SQLite Storage](/spin/sqlite-api-guide) | Supported | -| [Serverless AI](/spin/serverless-ai-api-guide) | Supported | -| [Service Chaining](/spin/http-outbound#local-service-chaining) | Not supported | -| [MySQL](/spin/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | -| [PostgreSQL](/spin/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | -| [Outbound Redis](/spin/rust-components.md#storing-data-in-redis-from-rust-components) | Supported | +| [Outbound HTTP](https://spinframework.dev/rust-components.md#sending-outbound-http-requests) | Supported | +| [Configuration Variables](https://spinframework.dev/variables) | Supported | +| [Key Value Storage](https://spinframework.dev/kv-store-api-guide) | Supported | +| [SQLite Storage](https://spinframework.dev/sqlite-api-guide) | Supported | +| [Serverless AI](https://spinframework.dev/serverless-ai-api-guide) | Supported | +| [Service Chaining](https://spinframework.dev/http-outbound#local-service-chaining) | Not supported | +| [MySQL](https://spinframework.dev/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | +| [PostgreSQL](https://spinframework.dev/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | +| [Outbound Redis](https://spinframework.dev/rust-components.md#storing-data-in-redis-from-rust-components) | Supported | | **[wasi-cloud-core](https://github.com/WebAssembly/wasi-cloud-core) Drafts** | | [wasi-blobstore](https://github.com/WebAssembly/wasi-blobstore) | Not supported in Spin | | [wasi-config](https://github.com/WebAssembly/wasi-config) | Supported (2024-09-27 snapshot) | | [wasi-keyvalue](https://github.com/WebAssembly/wasi-keyvalue) | `store` interface supported (2024-10-17 snapshot); `atomics` and `batch` not supported | | [wasi-messaging](https://github.com/WebAssembly/wasi-messaging) | Not supported in Spin | | **Features** | -| [Component dependencies](/spin/v3/writing-apps.md#using-component-dependencies) | Supported | +| [Component dependencies](https://spinframework.dev/v3/writing-apps.md#using-component-dependencies) | Supported | | **Extensibility** | -| [Custom Triggers](/spin/extending-and-embedding) | Not supported | +| [Custom Triggers](https://spinframework.dev/extending-and-embedding) | Not supported | -To learn more about what feature support looks like for various programming languages, visit the [Spin Language Support Guide](/spin/language-support-overview.md). +To learn more about what feature support looks like for various programming languages, visit the [Spin Language Support Guide](https://spinframework.dev/language-support-overview.md). ### Other Limitations - You cannot communicate between Spin applications using local name resolution -- [Runtime configuration and secrets](/spin/dynamic-configuration#runtime-configuration) are not supported at this time +- [Runtime configuration and secrets](https://spinframework.dev/dynamic-configuration#runtime-configuration) are not supported at this time ## Technical Frequently Asked Questions diff --git a/content/cloud/fermyon-cloud.md b/content/cloud/fermyon-cloud.md index bb0e66b44..2f3053cea 100644 --- a/content/cloud/fermyon-cloud.md +++ b/content/cloud/fermyon-cloud.md @@ -16,7 +16,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/fermyon-clou ## The Fermyon Cloud Explained -[The Fermyon Cloud](https://cloud.fermyon.com) is a cloud application platform for WebAssembly microservices. It enables you to run [Spin applications](/spin), at scale, in the cloud, without any infrastructure setup. +[The Fermyon Cloud](https://cloud.fermyon.com) is a cloud application platform for WebAssembly microservices. It enables you to run [Spin applications](https://spinframework.dev), at scale, in the cloud, without any infrastructure setup. In this article we describe the core technologies and concepts which are part of the Fermyon Cloud. diff --git a/content/cloud/github-actions.md b/content/cloud/github-actions.md index fa14f7502..984002cef 100644 --- a/content/cloud/github-actions.md +++ b/content/cloud/github-actions.md @@ -27,8 +27,8 @@ In this tutorial, you'll create an application and deploy it from GitHub to Ferm ## Prerequisites To ensure the tutorial goes smoothly, please check you have the following: -* Spin 1.0 or above [installed](/spin/quickstart#install-spin). You can check the version using `spin --version`. -* Spin templates [installed](/spin/quickstart#install-a-template). You can check with `spin templates list`. +* Spin 1.0 or above [installed](https://spinframework.dev/quickstart#install-spin). You can check the version using `spin --version`. +* Spin templates [installed](https://spinframework.dev/quickstart#install-a-template). You can check with `spin templates list`. * The [GitHub CLI](https://cli.github.com/manual/) installed. * A Fermyon Cloud account that is set up via your preferred [GitHub user account](https://docs.github.com/account-and-profile/setting-up-and-managing-your-personal-account-on-github/managing-email-preferences/remembering-your-github-username-or-email) @@ -396,5 +396,5 @@ Congratulations on deploying your first Spin application using GitHub Actions! ## Next Steps - Learn more about the [Fermyon GitHub Actions](https://github.com/fermyon/actions) collection -- To learn more about how to develop Spin applications, head over to the [Spin documentation](/spin/index) +- To learn more about how to develop Spin applications, head over to the [Spin documentation](https://spinframework.dev/index) - Find known issues and file new ones in the [Fermyon Cloud Feedback repository](https://github.com/fermyon/feedback) diff --git a/content/cloud/index.md b/content/cloud/index.md index 22a26f4d8..25952c0f2 100644 --- a/content/cloud/index.md +++ b/content/cloud/index.md @@ -10,7 +10,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/index.md" - [Getting Support](#getting-support) - [Open Beta](#open-beta) -[The Fermyon Cloud](https://cloud.fermyon.com) is a cloud application platform for WebAssembly-based serverless functions and microservices. It enables you to run [Spin applications](/spin), at scale, in the cloud, without any infrastructure setup or maintenance required. You can take the same Spin applications you were running locally with `spin up` and push them to Fermyon Cloud with a simple `spin deploy` command. That's just the beginning; let's take a closer look at what you can learn about with the Fermyon Cloud documentation. +[The Fermyon Cloud](https://cloud.fermyon.com) is a cloud application platform for WebAssembly-based serverless functions and microservices. It enables you to run [Spin applications](https://spinframework.dev), at scale, in the cloud, without any infrastructure setup or maintenance required. You can take the same Spin applications you were running locally with `spin up` and push them to Fermyon Cloud with a simple `spin deploy` command. That's just the beginning; let's take a closer look at what you can learn about with the Fermyon Cloud documentation. ## Documentation @@ -19,7 +19,7 @@ This site contains documentation to help you succeed in deploying and managing r - Learn how to get started in 66 seconds or less with the [Fermyon Cloud quickstart](quickstart) - Become familiar with how to [deploy](deploy), [upgrade](upgrade), and [delete](delete) a Spin application on Fermyon Cloud - Find information about the [conceptual architecture of the Fermyon Cloud](fermyon-cloud), -- Find reference documentation for the Fermyon Cloud [API](rest-api) and [Spin CLI](cli-reference), +- Find reference documentation for the Fermyon Cloud [API](rest-api), - Dive into a few sample application tutorials for inspiration (e.g. [Persistent Data: Redis](data-redis)) - Learn more via the [Frequently Asked Questions (FAQ) and known limitations sections](faq) @@ -32,4 +32,4 @@ If you have any questions (and cannot find answers) on this site, please go to o The Fermyon Cloud is currently an open beta service. This means that Fermyon Technologies does not provide any service-level agreements on the service, including the workloads you choose to deploy. We also reserve the right to break compatibility with: - The Fermyon Cloud [OpenAPI integration](rest-api). For example, the automatically generated client libraries (that your project can optionally use to integrate with the Fermyon Cloud via REST API) may change -- Support for previous and current versions of the [Spin SDK](/spin) \ No newline at end of file +- Support for previous and current versions of the [Spin SDK](https://spinframework.dev) \ No newline at end of file diff --git a/content/cloud/kv-cloud-tutorial.md b/content/cloud/kv-cloud-tutorial.md index 5c878b83c..b5200d15e 100644 --- a/content/cloud/kv-cloud-tutorial.md +++ b/content/cloud/kv-cloud-tutorial.md @@ -15,19 +15,19 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/kv-cloud-tut - [Deleting the Cloud Key Value Store](#deleting-the-cloud-key-value-store) - [Next Steps](#next-steps) -With Spin Key Value Store support in Fermyon Cloud, you can persist non-relational data generated by your [Spin](../spin/install.md) beyond application invocations. Fermyon Cloud will provision and manage the database on your behalf, letting Fermyon Cloud do the heavy lifting for you. To learn more about the Spin Key Value Store SDK, please visit the [API guide](../spin/v2/kv-store-api-guide.md). +With Spin Key Value Store support in Fermyon Cloud, you can persist non-relational data generated by your [Spin](https://spinframework.dev/install.md) beyond application invocations. Fermyon Cloud will provision and manage the database on your behalf, letting Fermyon Cloud do the heavy lifting for you. To learn more about the Spin Key Value Store SDK, please visit the [API guide](https://spinframework.dev/v2/kv-store-api-guide.md). -This tutorial will focus primarily on linking your Spin applications to Fermyon Cloud Key Value Stores. To learn more how to configure business login within a Spin application to access key value data, please visit the [Spin Key Value tutorial](../spin/v2/key-value-store-tutorial). Fermyon Cloud supports linking Spin applications to storage objects such as SQL databases and key value stores. Links connect your Spin application to a Fermyon Cloud managed store via an associated label. That label is scoped to only the Spin application you are linking. This enables developers to abstractly declare that their application should have access to a key value stores, while giving them the ability to dynamically change which key value store it uses at any point. For an in depth review of these concepts, please visit [the links and labels conceptual article](linking-applications-to-resources-using-labels.md) +This tutorial will focus primarily on linking your Spin applications to Fermyon Cloud Key Value Stores. To learn more how to configure business login within a Spin application to access key value data, please visit the [Spin Key Value tutorial](https://spinframework.dev/v2/key-value-store-tutorial). Fermyon Cloud supports linking Spin applications to storage objects such as SQL databases and key value stores. Links connect your Spin application to a Fermyon Cloud managed store via an associated label. That label is scoped to only the Spin application you are linking. This enables developers to abstractly declare that their application should have access to a key value stores, while giving them the ability to dynamically change which key value store it uses at any point. For an in depth review of these concepts, please visit [the links and labels conceptual article](linking-applications-to-resources-using-labels.md) -> Please check that you have [Spin CLI](../spin/v2/cli-reference.md) v2.0 or greater, and [`cloud` plugin](https://github.com/fermyon/cloud-plugin) v0.7.0 or greater installed. +> Please check that you have [Spin CLI](https://spinframework.dev/install) v2.0 or greater, and [`cloud` plugin](https://github.com/fermyon/cloud-plugin) v0.7.0 or greater installed. ## Creating a New Spin Application -If you already have a Spin application, you can skip this step. If you do not have a Spin application locally you will need to [create one](/spin/quickstart#create-your-first-application). +If you already have a Spin application, you can skip this step. If you do not have a Spin application locally you will need to [create one](https://spinframework.dev/quickstart#create-your-first-application). ## Grant Key Value Store Permission -To tell Spin that we want to use a key value store, we only need to [grant key value store permission to a component in the application’s manifest](/spin/kv-store-api-guide#granting-key-value-store-permissions-to-components) (the `spin.toml` file) by supplying a [label](linking-applications-to-resources-using-labels.md). For example: +To tell Spin that we want to use a key value store, we only need to [grant key value store permission to a component in the application’s manifest](https://spinframework.dev/kv-store-api-guide#granting-key-value-store-permissions-to-components) (the `spin.toml` file) by supplying a [label](linking-applications-to-resources-using-labels.md). For example: ``` [component.example] diff --git a/content/cloud/linking-applications-to-resources-using-labels.md b/content/cloud/linking-applications-to-resources-using-labels.md index 4d982c738..88bfa76c5 100644 --- a/content/cloud/linking-applications-to-resources-using-labels.md +++ b/content/cloud/linking-applications-to-resources-using-labels.md @@ -17,7 +17,7 @@ Many Spin applications require data storage between invocations. Fermyon Cloud o To facilitate the seamless transition of applications between different environments, such as from a local development environment to Fermyon Cloud, Spin applications don't reference databases by their physical location, like a connection string. Instead, they use a label. A label is an abstract identifier, such as "default," "user-accounts," or "transactions." The environment determines how this label is mapped to a physical database. -In the Spin development environment, that mapping is handled by the [runtime configuration file](/spin/dynamic-configuration#runtime-configuration). In Fermyon Cloud, it's managed through _links_. +In the Spin development environment, that mapping is handled by the [runtime configuration file](https://spinframework.dev/dynamic-configuration#runtime-configuration). In Fermyon Cloud, it's managed through _links_. > Link management is currently available for SQLite Databases and Key Value Stores. In this article, we will showcase SQLite Databases, although you can apply the same concepts to Key Value Stores as well. @@ -209,5 +209,5 @@ If you delete a Fermyon Cloud application, it removes any links associated with ## Next Steps * Review the [SQLite Database Tutorial](noops-sql-db.md) to learn how to use links and labels with your SQLite Database -* Review the [Key Value Store Tutorial](../spin/v2/key-value-store-tutorial.md) +* Review the [Key Value Store Tutorial](https://spinframework.dev/v2/key-value-store-tutorial.md) * Visit the [Spin Cloud Plugin](cloud-command-reference.md) reference article to learn more about the `spin cloud link sqlite` commands diff --git a/content/cloud/noops-sql-db.md b/content/cloud/noops-sql-db.md index 895442051..610575a30 100644 --- a/content/cloud/noops-sql-db.md +++ b/content/cloud/noops-sql-db.md @@ -16,11 +16,11 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/noops-sql-db - [Deleting the Cloud Database](#deleting-the-cloud-database) - [Next Steps](#next-steps) -With SQLite Database support in Fermyon Cloud, you can persist relational data generated by your [Spin](../spin/install.md) application in between application invocations without worrying about database management. Fermyon Cloud will provision and manage the database on your behalf:, no operations are required. Fermyon Cloud will do the heavy lifting for you. To learn more about the Spin SQLite SDK, please visit the [API guide](../spin/sqlite-api-guide.md). +With SQLite Database support in Fermyon Cloud, you can persist relational data generated by your [Spin](https://spinframework.dev/install.md) application in between application invocations without worrying about database management. Fermyon Cloud will provision and manage the database on your behalf:, no operations are required. Fermyon Cloud will do the heavy lifting for you. To learn more about the Spin SQLite SDK, please visit the [API guide](https://spinframework.dev/sqlite-api-guide.md). -> Please check that you have [Spin CLI](./cli-reference.md) v1.4 or greater, and [`cloud` plugin](https://github.com/fermyon/cloud-plugin) v0.3.1 or greater installed. +> Please check that you have [Spin CLI](https://spinframework.dev/install) v1.4 or greater, and [`cloud` plugin](https://github.com/fermyon/cloud-plugin) v0.3.1 or greater installed. ## Service Limitations For the Database in Fermyon Cloud @@ -28,11 +28,11 @@ With SQLite Database support in Fermyon Cloud, you can persist relational data g ## Creating a New Spin Application -If you already have a Spin application, you can skip this step. If you do not have a Spin application locally you will need to [create one](/spin/quickstart#create-your-first-application). +If you already have a Spin application, you can skip this step. If you do not have a Spin application locally you will need to [create one](https://spinframework.dev/quickstart#create-your-first-application). ## Grant SQLite Permission -To tell Spin that we want to use SQLite storage, we only need to [grant SQLite permission to a component in the application’s manifest](/spin/sqlite-api-guide#granting-sqlite-database-permissions-to-components) (the `spin.toml` file) by supplying a [label](linking-applications-to-resources-using-labels.md). For example: +To tell Spin that we want to use SQLite storage, we only need to [grant SQLite permission to a component in the application’s manifest](https://spinframework.dev/sqlite-api-guide#granting-sqlite-database-permissions-to-components) (the `spin.toml` file) by supplying a [label](linking-applications-to-resources-using-labels.md). For example: ``` [component.example] @@ -43,7 +43,7 @@ The new database file (`sqlite_db.db`) is created in your application's `.spin` ## Managing Your Local Spin Database Schema -See [preparing an SQLite Database](../spin/sqlite-api-guide#preparing-an-sqlite-database) for more information on using the `spin up` subcommand's `--sqlite` option to create and populate tables locally. No **Cloud** database is created or changed as a result of using this this optional `spin up --sqlite` example. Populating this local database can be useful for testing (the relationship between your application's logic and your schema) before deploying your application to Fermyon Cloud. +See [preparing an SQLite Database](https://spinframework.dev/sqlite-api-guide#preparing-an-sqlite-database) for more information on using the `spin up` subcommand's `--sqlite` option to create and populate tables locally. No **Cloud** database is created or changed as a result of using this this optional `spin up --sqlite` example. Populating this local database can be useful for testing (the relationship between your application's logic and your schema) before deploying your application to Fermyon Cloud. When developing locally, you may also want to test queries, check tables were created properly, or inspect the data in your local SQLite database. [`sqlite3`](https://sqlite.org/cli.html) is a command line program that allows users to evaluate queries interactively. You can point the `sqlite3` CLI to the `.spin/sqlite_db.db` file, located in your application directory, to view or modify your database directly. _Note: `.spin/sqlite_db.db` is created on `spin up`._ diff --git a/content/cloud/quickstart.md b/content/cloud/quickstart.md index 70cd94d7f..f00d085e6 100644 --- a/content/cloud/quickstart.md +++ b/content/cloud/quickstart.md @@ -71,7 +71,7 @@ Unzip the binary release and place the `spin.exe` in your system path. {{ blockEnd }} -{{ details "Learn more" "[Spin](https://github.com/spinframework/spin) is an open-source project used for creating, developing, building, running, and deploying Spin applications. It is both a CLI tool and a runtime, and provides SDKs for a variety of programming languages, including, but not limited to, Rust, TinyGo, and C#. \n\n The Spin project provides installers that are supported on Linux (amd64), macOS (amd64 and arm64), and Windows(amd64). \n\n The [Spin](/spin) documentation is a good starting place to learn more about using the framework to develop applications."}} +{{ details "Learn more" "[Spin](https://github.com/spinframework/spin) is an open-source project used for creating, developing, building, running, and deploying Spin applications. It is both a CLI tool and a runtime, and provides SDKs for a variety of programming languages, including, but not limited to, Rust, TinyGo, and C#. \n\n The Spin project provides installers that are supported on Linux (amd64), macOS (amd64 and arm64), and Windows(amd64). \n\n The [Spin](https://spinframework.dev) documentation is a good starting place to learn more about using the framework to develop applications."}} ## Log in to the Fermyon Cloud @@ -112,7 +112,7 @@ $ git clone https://github.com/fermyon/cloud-start && cd cloud-start This command clones the repository into a local directory named `cloud-start`, and then enters that directory. -{{ details "Learn more" "To write your Spin application, you would start by using the command `spin new [template name] [project name]`. This gives you the option to select a template based on your preference of programming language and trigger for your module - e.g., `spin new rust-http my_rust_http_trigger`. \n\n The [Spin quickstart](/spin/quickstart) guides you through creating a Spin application from scratch." }} +{{ details "Learn more" "To write your Spin application, you would start by using the command `spin new [template name] [project name]`. This gives you the option to select a template based on your preference of programming language and trigger for your module - e.g., `spin new rust-http my_rust_http_trigger`. \n\n The [Spin quickstart](https://spinframework.dev/quickstart) guides you through creating a Spin application from scratch." }} ## Deploy the Application diff --git a/content/cloud/variables.md b/content/cloud/variables.md index f73d17942..a42ebad1e 100644 --- a/content/cloud/variables.md +++ b/content/cloud/variables.md @@ -14,7 +14,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/variables.md Spin supports dynamic application variables. Instead of being static, their values can be updated without modifying the application, creating a simpler experience for rotating secrets, updating API endpoints, and more. -These variables are defined in a Spin application manifest (in the `[variables]` section) and are provided by a configuration provider. When using Spin locally, the configuration provider can be Vault for secrets or host environment variables. You can refer to the [dynamic configuration documentation](/spin/dynamic-configuration.md) to learn how to configure variables locally. In Fermyon Cloud, you can set and update variables for Spin applications using the [`spin cloud variables`](/cloud/cloud-command-reference.md#spin-cloud-variables) command. +These variables are defined in a Spin application manifest (in the `[variables]` section) and are provided by a configuration provider. When using Spin locally, the configuration provider can be Vault for secrets or host environment variables. You can refer to the [dynamic configuration documentation](https://spinframework.dev/dynamic-configuration.md) to learn how to configure variables locally. In Fermyon Cloud, you can set and update variables for Spin applications using the [`spin cloud variables`](/cloud/cloud-command-reference.md#spin-cloud-variables) command. This tutorial will guide you through the process of creating a simple application that validates passwords. If you prefer to learn through video, you can follow along with this recording. @@ -32,7 +32,7 @@ python3 --version If you do not have Python 3.10 or later, you can install it by following the instructions [here](https://www.python.org/downloads/). -Since this example is written in Python, make sure you have the required tools installed to write Spin applications in Python. The Spin CLI facilitates the creation of new Spin applications using application [templates](/cloud/cli-reference#templates). In this tutorial, we will use the `http-py` template that provides a `requirements.txt` file to handle dependencies: +Since this example is written in Python, make sure you have the required tools installed to write Spin applications in Python. The Spin CLI facilitates the creation of new Spin applications using application [templates](https://spinframework.dev/managing-templates). In this tutorial, we will use the `http-py` template that provides a `requirements.txt` file to handle dependencies: @@ -190,7 +190,7 @@ class IncomingHandler(IncomingHandler): bytes(response, "utf-8")) ``` -Build and run the application locally to test it out. We will use the [environment variable provider](/spin/dynamic-configuration.md#environment-variable-provider) to set the variable values locally. The provider gets the variable values from the `spin` process's environment, searching for environment variables prefixed with `SPIN_VARIABLE_`: +Build and run the application locally to test it out. We will use the [environment variable provider](https://spinframework.dev/dynamic-configuration.md#environment-variable-provider) to set the variable values locally. The provider gets the variable values from the `spin` process's environment, searching for environment variables prefixed with `SPIN_VARIABLE_`: @@ -258,4 +258,4 @@ $ spin cloud variables list --app "pw_checker" Congratulations 🎉! You've built and deployed your first dynamically configurable Spin application. -If you want to do more with your Spin applications, check out tutorials on persisting data in Fermyon Cloud, whether with the [built-in key/value service](/spin/key-value-store-tutorial.md), [Redis](/cloud/data-redis.md), or [PostgreSQL](/cloud/data-postgres.md). +If you want to do more with your Spin applications, check out tutorials on persisting data in Fermyon Cloud, whether with the [built-in key/value service](https://spinframework.dev/key-value-store-tutorial.md), [Redis](/cloud/data-redis.md), or [PostgreSQL](/cloud/data-postgres.md). diff --git a/content/common/contributing-docs.md b/content/common/contributing-docs.md new file mode 100644 index 000000000..9da0a81b7 --- /dev/null +++ b/content/common/contributing-docs.md @@ -0,0 +1,587 @@ +title = "Contributing to Docs" +template = "common_main" +date = "2023-11-04T00:00:01Z" +[extra] +url = "https://github.com/fermyon/developer/blob/main/content/common/contributing-docs.md" +keywords = "contribute contributing" + +--- + +- [Technical Documentation Types](#technical-documentation-types) + - [1. Tutorials](#1-tutorials) + - [2. How-To Guides](#2-how-to-guides) + - [3. Reference](#3-reference) + - [4. Explanation](#4-explanation) +- [Documents Relevant to Two or More Projects](#documents-relevant-to-two-or-more-projects) +- [Technical Documentation Procedure (Video)](#technical-documentation-procedure-video) +- [Technical Documentation Procedure (Text)](#technical-documentation-procedure-text) + - [1. Fork the Repository](#1-fork-the-repository) + - [2. Clone the Fork](#2-clone-the-fork) + - [3. Create New Branch](#3-create-new-branch) + - [4. Add Upstream](#4-add-upstream) + - [5. Code Blocks, Annotations and Table of Contents (ToC)](#5-code-blocks-annotations-and-table-of-contents-toc) + - [6.1 Checking Your Content - Using NPM](#61-checking-your-content---using-npm) + - [6.2 Indexing Your Content](#62-indexing-your-content) + - [6.3 Increasing Search Visibility For Your Content](#63-increasing-search-visibility-for-your-content) + - [6.4 The Edit On GitHub Button](#64-the-edit-on-github-button) + - [6.5 How To Properly Edit CSS Styles](#65-how-to-properly-edit-css-styles) + - [6.6 Checking Your Content - Using Bartholomew's CLI](#66-checking-your-content---using-bartholomews-cli) + - [6.7 Checking Your Content - Preview a Documentation Page on Localhost](#67-checking-your-content---preview-a-documentation-page-on-localhost) + - [6.8 Scheduling Menu Items for Timed Release](#68-scheduling-menu-items-for-timed-release) + - [7. Checking Web Pages](#7-checking-web-pages) + - [8. Add Changes](#8-add-changes) + - [9. Commit Changes](#9-commit-changes) + - [10. Push Changes](#10-push-changes) + - [11. Create a Pull Request](#11-create-a-pull-request) + +We are delighted that you are interested in making our developer documentation better. Thank you! We welcome and appreciate contributions of all types — opening issues, fixing typos, adding examples, one-liner code fixes, tests, or complete features. + +Any contribution and interaction on any Fermyon project MUST follow our [code of conduct](https://www.fermyon.com/code-of-conduct). Thank you for being part of an inclusive and open community! + +Below are a few pointers designed to help you contribute. + +## Technical Documentation Types + +The following points will help guide your contribution from a resource-type perspective; essentially we would really appreciate you creating and contributing any of the following 4 resource types. + +### 1. Tutorials + +Tutorials are oriented toward learning. Tutorials are designed to get a user started on something new (that they have not tried before). You can think of a tutorial as a lesson i.e. teaching a Spin user [how to use Redis to persist data](/cloud/data-redis). The tutorial may contain many logically ordered steps i.e. installing Spin, installing Redis, using Spin templates, configuring a Spin application and so forth. The desired outcome for a tutorial is for the user to have a working deployment or application. Think of it as a lesson in how to bake a cake. + +### 2. How-To Guides + +How-to guides are oriented towards showing a user how to solve a problem, which leads them to be able to achieve their own goal. The how-to guide will follow a series of logical steps. Think of it as providing a recipe for the user's creativity. For example, you can show a user how to [develop a Spin application](/cloud/develop) without telling them what the application must do; that is up to the user's imagination. + +### 3. Reference + +Reference resources are merely a dry description; describing the feature in its simplest form. An example of a reference resource is the [Spin application manifest reference](https://spinframework.dev/manifest-reference). You will notice that the Manifest Reference page simply lists all of the manifest entries and available options. + +### 4. Explanation + +An explanation resource is written using a deep-dive approach i.e. providing a deep explanation with the view to impart a deep understanding of a particular concept, feature or product. You may find your contribution is so in-depth that it becomes a long form article like a blog post. If that is the case, please get in touch and we can discuss options around getting your content published on another platform; like the [Fermyon Blog](https://www.fermyon.com/blog/index). + +**Tying It All Together** + +You will notice that the menu system is organized in terms of "Tutorial", "How-To", "Reference" and so forth. When you write your contribution please decide which product (Cloud, Spin, Bartholomew) category it falls into and also which resource type it aligns with. Armed with that information you can go ahead and create your new file. For example, your "how-to" resource on "developing a Spin application" in Fermyon cloud would be saved to the `content/cloud/` folder; specifically, `content/cloud/develop.md` and the menu item (for the left-hand-side menu) would be added to the `templates/cloud_sidebar.hbs` file, as shown below. + +![cloud develop example](/static/image/docs/cloud-develop-example.png) + +The resulting output would be as follows. + +![cloud develop example](/static/image/docs/cloud-develop-example-2.png) + +## Documents Relevant to Two or More Projects + +If a document is relevant to two or more projects, the dynamic body feature of bartholomew is to be used. Create the document in one of the projects with the content. In the other project(s) create a file with only the frontmatter. Then add the following field to the frontmatter: + + + +```toml +. +. +body_source = "" + +[extra] + +``` + +The value for the `body_source` key, should be the path from which the content is being shared (relative to the repository's `content` folder). For example if the Spin project's `developer/content/common/contributing-docs.md` holds the sharable content (as the single source of truth), then the Cloud project can display that same content by using the following frontmatter: + + + +```toml +title = "Contributing to Docs" +template = "cloud_main" +date = "2023-11-04T00:00:01Z" +body_source = "/common/contributing-docs" + +[extra] +url = "https://github.com/fermyon/developer/blob/main/content/cloud/contributing-docs.md" +keywords = "contribute contributing" + +--- +``` + +> Note: the `body_source = "/spin/contributing-docs"` part of the frontmatter does not need to include the `.md` file extension (as is also the case when hyperlinking via markdown anywhere in a developer documentation file's body). + +## Technical Documentation Procedure (Video) + + + +## Technical Documentation Procedure (Text) + +### 1. Fork the Repository + +The first step is to fork the [developer repository](https://github.com/fermyon/developer), from Fermyon's GitHub, to your own GitHub account. + +![Fork the repository](/static/image/fork_developer_repo.png) + +Ensure that you are forking the developer repository **to your own** GitHub account; where you have full editing privileges. + +### 2. Clone the Fork + +Copy the URL from the UI in readiness for running the `git clone` command. + +![Fork the repository](/static/image/clone_developer_repo.png) + +Go ahead and clone the new fork that you just created (the one which resides in your own GitHub account): + + + +```bash +$ cd ~ +$ git clone git@github.com:yourusername/developer.git +$ cd developer +``` + +### 3. Create New Branch + +Create a new branch that will house all of your changes for this specific contribution: + + + +```bash +$ git checkout -b my_new_branch +``` + +### 4. Add Upstream + +Create a new remote for the upstream (a pointer to the original repository to which you are contributing): + + + +```bash +$ git remote add upstream https://github.com/fermyon/developer +``` + +### 5. Code Blocks, Annotations and Table of Contents (ToC) + +It is highly recommended that you use either the `` or the `` annotation before each of your code blocks, and that each code block defines the appropriate [syntax highlighting](https://rdmd.readme.io/docs/code-blocks#language-support). The annotation can be skipped for code blocks with example code snippets i.e. non-terminal or generic output examples. + +**Selective copy** + +The selective copy annotation (``) is intended for use when communicating code and/or CLI commands for the reader to copy and paste. The selective copy annotation allows the reader to see the entire code block (both commands and results) but only copies the lines that start with `$` into the reader's clipboard (minus the `$`) when the user clicks the copy button. For example, copying the following code block will only copy `echo "hello"` into your clipboard, for pasting. + + + +```bash +$ echo "hello" +hello +``` + +> Note: If the command, that starts with `$`, is deliberately spread over two lines (by escaping the newline character), then the copy mechanism will still copy the second line which is technically still part of that single command. + +**No copy** + +The no copy annotation (``) precedes a code block where no copy and pasting of code is intended. If using the no copy attribute please still be sure to add the appropriate syntax highlighting to your code block (for display purposes). For example: + +![No Copy Source Code Example](/static/image/no-copy-source-code-example.png) + +Please find copyable snippet below, for your convenience: + +```` + + +```text +Some generic code not intended for copying/pasting +``` +```` + +The above markdown will render the following code block on the web page: + + + +```text +Some generic code not intended for copying/pasting +``` + +**Non-selective copy** - just a straight copy without any additional features. + +If you want the code in a code block to be copyable with no "smarts" to remove the `$` then you can just simply leave out the annotation altogether. A code block in markdown will be copyable without smarts just as is. + +**Multi-tab code blocks** + +Multi-tab code blocks [have recently been implemented](https://github.com/fermyon/developer/pull/239). Examples can be seen in the [Spin installer documentation](https://spinframework.dev/install#installing-spin) and [Spin Key/Value documentation](https://spinframework.dev/key-value-store-tutorial#the-spin-toml-file). The above examples demonstrate how tabs can either represent platforms i.e. `Windows`, `Linux` and `macOS` or represent specific programming languages i.e. `Rust`, `JavaScript` and `Golang` etc. Here is a brief example of how to implement multi-tab code blocks when writing technical documentation for this site, using markdown. + +The first step to implementing multi-tab code blocks is placing the `enable_shortcodes = true` configuration at the start of the `.md` file. Specifically, in the `.md` file's frontmatter. + +The markup to create tabs in markdown is as follows + +``` +{{ tabs "os" }} + +{{ startTab "Windows"}} + +To list files on windows use `dir` + + + +\`\`\`bash +$ dir hello_fermyon +\`\`\` +and script in windows have the extension `.bat` + + + +\`\`\`bash +hello.bat +test.bat +\`\`\` + +{{ blockEnd }} + +{{ startTab "Linux"}} + +To list files on linux use `ls` + + + +\`\`\`bash +$ ls +\`\`\` + +and script in linux have the extension `.sh` + + + +\`\`\`bash +hello.sh +test.sh +\`\`\` + +{{ blockEnd }} +{{ blockEnd }} +``` + +**Note**: Existing documentation will already be using class names for code block `tabs` and `startTab` i.e. `{{ tabs "os" }}` and `{{ startTab "Windows"}}` respectively. Please consult the following `tabs` and `startTab` class names that are already in use (before creating your own). If you need to create a new class name (because one does not already exist) please add it to the list below as part of the pull request that contains your code block contribution. + +**tabs**: +- `gh-interact` +- `os` +- `platforms` +- `sdk-type` +- `spin-version` +- `cloud-plugin-version` + +**startTab** +- `Azure AKS` +- `C#` +- `Docker Desktop` +- `Generic Kubernetes` +- `GitHub CLI` +- `GitHub UI` +- `K3d` +- `Linux` +- `macOS` +- `Python` +- `Rust` +- `TinyGo` +- `TypeScript` +- `v0.9.0` +- `v0.10.0` +- `v1.0.0` +- `v1.1.0` +- `v1.2.0` +- `v0.1.0` +- `v0.1.1` +- `Windows` + +The next section covers the highly recommended use of ToCs. + +**Implementing a Table of Contents (ToC)** + +If you create content with many headings it is highly recommended to place a ToC in your markdown file. There are excellent extensions (such as this Visual Studio Code Extension called [markdown-all-in-one](https://marketplace.visualstudio.com/items?itemName=yzhang.markdown-all-in-one) which will automatically generate your ToC). + +### 6.1 Checking Your Content - Using NPM + +Once you are satisfied with your contribution, you can programmatically check your content. + +If you have not done so already, please go ahead and perform the `npm ci` (npm clean install) command; to enable Node dependencies such as `markdownlint-cli2`. Simply run the following command, from the root of the developer repository: + + + +```bash +$ npm ci +``` + +On top of the Node dependencies the `timeout` executable must be installed on your system and added to the `PATH` environment variable. The `timeout` executable is included in the [gnu coreutils package](https://www.gnu.org/software/coreutils/) which should be present in most Linux distributions. + +On macOS you can install the `timeout` binary using the Homebrew package manager as shown below: + + + +```bash +$ brew install coreutils +``` + +Having all dependencies installed, you can now check for broken links (which takes several minutes) and also lint your markdown files. Simply run the following command, from the root of the developer repository: + + + +```bash +$ npm run test +``` + +**Hint:** Optionally you can run only the linter with the following command: + + + +```bash +# Example of how to lint all Markdown files in a local folder (in this case the spin folder) +npx markdownlint-cli2 content/spin/*.md \"#node_modules\" +# Example of how to lint a local Markdown file +npx markdownlint-cli2 content/spin/install.md \"#node_modules\" +``` + +**Note:** Whilst the `npm run test` command (which lints and also programmatically checks all URLs) does take extra time to complete it **must** be utilized before you [push changes](#10-push-changes); preventing the potential pushing of broken URLs to the developer documentation site. + +### 6.2 Indexing Your Content + +The developer documentation site implements in-house search. A new index is automatically generated for you when your contribution is merged into the developer documentation repository. This is done via a GitHub action. The following section explains how to alter content to increase search visibility for your content. + +### 6.3 Increasing Search Visibility For Your Content + +The built-in search functionality is based on the indexing of individual words in each markdown file, which works well most of the time. However, there are a couple of scenarios where you _may_ want to deliberately increase search visibility for your content. + +**Word Mismatch** + +Words in a documentation markdown file may not be words that are searched for by a user. For example, you may write about "different HTTP listening options" whereas a user may only ever try to find that specific content using a search phrase like "alternate port". If you are aware of typical user search phrases it is always recommended to craft your content to include any predictable user search phrases. However, in the rare case of a mismatch between words in your content and the words a user searches for, you can utilize use the `keywords` string in the `[extra]` section of your document's frontmatter to increase visibility. For example, the following code block shows frontmatter that helps a user find your documentation page (when the user searches for `port`): + +```markdown +[extra] +keywords = "port ports" +``` + +Adding a word to the `keywords` string of a page overrides the built-in search functionality by at least one order of magnitude. Adding a word to the `keywords` string may displace other content, so please use it only if necessary. + +**Homing in on specific content** + +The `keywords` string takes users to the start of a page. In some cases, this is not ideal. You may want to home in on specific content to resolve a search query. + +If a search term relates to a specific part of a page, you may use the following syntax anywhere in the body of your markdown file, and the user's search action will direct them straight to the previous heading (nearest heading above the `@searchTerm` syntax). + +```markdown + +``` + + + +When using the above `@searchTerm` feature, please note the following: +- the words must be separated by a space i.e. +- these keywords will be boosted in the search results by at least one order of magnitude; so please use them with caution, so as not to displace other valid pages containing similar content. + +Example: If you search for the word "homing", the results will point you to the previous heading in this specific section of the developer documentation. + +![homing example](/static/image/homing.png) + +### 6.4 The Edit On GitHub Button + +Each markdown file in the developer documentation requires a link to its GitHub page for the site to correctly render the "Edit on GitHub" button for that page. + +![edit on github](/static/image/edit-on-github.png) + +If you create a new markdown file and/or you notice a file without the explicit GitHub URL, please add a URL entry to the [extra] section. For example, the following `url` is required for this page that you are reading (you can check the raw markdown contents of this page to see this example): + +``` +[extra] +url = "https://github.com/fermyon/developer/blob/main/content/cloud/contributing-docs.md" +``` + +### 6.5 How To Properly Edit CSS Styles + +> The following section (the running of the `npm run styles` command) is not necessary unless you are editing styles i.e. updating `.scss` files, in order to generate new `.css` files, as part of your contribution. + +Directly editing `.css` files is not recommended, because `.css` files are overwritten. Instead, if you would like to make and test a new/different style please go ahead and update the appropriate `.scss` file. The following command will automatically update the `.css` file that is relevant to the `.scss` file that you are editing: + + + +```bash +$ npm run styles +``` + +The above command is designed to be run in the background; enabling you to view your design changes (that are reflected in the `.css`) while you are editing the `.scss` in real-time. If you are not running this command in the background (i.e. just deliberately regenerating the `.css` files once), then the above command can be stopped by pressing `Ctrl` + `C`. + +### 6.6 Checking Your Content - Using Bartholomew's CLI + +The Bartholomew Command Line Interface (CLI) Tool is called `bart`. The `bart` CLI is a tool that simplifies working with Bartholomew projects (by now you probably already know that [Bartholomew](https://www.fermyon.com/blog/introducing-bartholomew) is our in-house WebAssembly (Wasm) content management system (CMS) that powers [our official Website](https://www.fermyon.com/)). And this (our official documentation) site. The `bart` CLI is handy to ensure quality assurance of new and existing content. Installing the CLI is a cinch, so please go ahead and use it when contributing. + +To build the Bartholomew CLI from source perform the following commands: + + + +```bash +$ cd ~ +$ git clone https://github.com/fermyon/bartholomew.git +$ cd ~/bartholomew +$ make bart +``` + +Once built, you will find the `bart` CLI executable in the `~/bartholomew/target/release` directory. However, for convenience it would be a great idea to go ahead and add the `bart` executable to your system path, for example: + + + +```bash +$ sudo mv ~/bartholomew/target/release/bart /usr/local/bin/ +``` + +Once installed, you can use the CLI's `--help` flag to learn more. For example: + + + +```bash +$ bart --help +bart 0.6.0 +The Bartholomew CLI + +USAGE: + bart + +FLAGS: + -h, --help Prints help information + -V, --version Prints version information + +SUBCOMMANDS: + calendar Print the content calendar for a Bartholomew website + check Check content and identify errors or warnings + help Prints this message or the help of the given subcommand(s) + new Create a new page or website from a template +``` + +Let's take a quick look at how you can use the `bart` CLI to check any content that you are wanting to contribute. + +### 6.7 Checking Your Content - Preview a Documentation Page on Localhost + +You can host your changes to the developer documentation on your own machine (localhost) by using the following `spin` commands: + + + +```bash +$ npm ci +$ cd spin-up-hub +$ npm ci +$ cd .. +$ spin build +$ spin up -e "PREVIEW_MODE=1" +``` + +> Please note: using the `PREVIEW_MODE=1` as part of a `spin` command is safe on localhost and allows you to view the content (even if the `date` setting in the content's `.md` is set to a future date). It is often the case that you will be checking content before the publishing date via your system. The developer documentation's manifest file `spin.toml` has the `PREVIEW_MODE` set to `0` i.e. `environment = { PREVIEW_MODE = "0" }`. This `spin.toml` file is correct for a production environment and should always be `0` (so that the CMS adheres to the publishing `date` setting for content on the public site). Simply put, you can use `PREVIEW_MODE=1` safely in your command line on your localhost but you should never update the `spin.toml` file (in this regard). + +### 6.8 Scheduling Menu Items for Timed Release + +As mentioned above, all pages (`.md` files) in the documentation have a UTC date i.e. `date = "2023-07-25T17:26:00Z"`. The `date` is a page scheduling mechanism whereby each page is only displayed if the `date` has elapsed. Menu items (found in the `/developer/templates/*.hbs` files) that relate to a scheduled page can also be scheduled (so the specific menu item and its associated page appear at the same time). Simply envelope the menu item with the following `if` syntax to synchronize the appearance of the menu item with the related page: + + + +``` +{{#if (timed_publish "2023-07-25T17:26:00Z" env.PREVIEW_MODE)}} + // Scheduled menu item for timed release +{{/if}} +``` + +> In order to keep the code tidy and readable it is advised to remove the `if` logic (from the `.hbs` file) that wraps the content, once the `timed_publish` has elapsed. + +### 7. Checking Web Pages + +The `bart check` command can be used to check the content. Simply pass in the content as a parameter. The developer documentation [uses shortcodes](/bartholomew/shortcodes), so always pass `--shortcodes ./shortcodes` as shown below: + + + +```bash +$ bart check --shortcodes ./shortcodes content/cloud/develop.md +shortcodes: registering alert +shortcodes: registering suh_cards +shortcodes: registering details +shortcodes: registering tabs +shortcodes: registering startTab +shortcodes: registering card_element +shortcodes: registering blockEnd +✅ content/cloud/develop.md +``` + +> Note: `using a wildcard `*` will check a whole directory via a single command. For example, running `bart check --shortcodes ./shortcodes content/cloud/*` will check all markdown files in the Spin project's documentation section. + +### 8. Add Changes + +Once your changes have been checked, go ahead and add your changes by moving to a top-level directory, under which your changes exist i.e. `cd ~/developer`. + +Add your changes by running the following command, from the root of the developer repository: + + + +```bash +$ git add +``` + +### 9. Commit Changes + +All commits must be signed off *and* GPG-signed with a GitHub verification key. The rest of this section is primarily for contributors not familiar with signing, and describes how to configure signing, and how to sign commits. + +First, ensure that your Git installation is configured sufficiently so that you can `--signoff` as part of the `git commit` command. Typically, you need the `user.name` and `user.email` to be configured in your Git session. You can check if these are set by typing `git config --list`. + +If you need to set these values please use the following commands: + + + +```bash +$ git config user.name "yourusername" +``` + + +```bash +$ git config user.email "youremail@somemail.com" +``` + +You must also set up a GPG verification key on your GitHub account, and add this to your Git settings. For more information about setting up a GPG verification key, see GitHub's documentation about [adding a GPG key to your GitHub account](https://docs.github.com/en/authentication/managing-commit-signature-verification/adding-a-gpg-key-to-your-github-account) and [telling your Git client about your GPG key](https://docs.github.com/en/authentication/managing-commit-signature-verification/telling-git-about-your-signing-key). + +With all this set up, type the following commit command, which both _signs off_ (--signoff) and _cryptographically signs_ the data (-S), and leaves a short commit message (-m): + + + +```bash +$ git commit -S --signoff -m "Updating documentation" +``` + +> Note: the `--signoff` option only adds a Signed-off-by trailer by the committer at the end of the commit log message. You must also use the `-S` option which will GPG-sign your commits. For more information about GPG-signing commits see [the GitHub documentation page for signing commits](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits). + +### 10. Push Changes + +At this stage, it is a good idea to just quickly check what GitHub thinks the origin is. For example, if we type `git remote -v` we can see that the origin is our repo; which we a) forked the original repo into and b) which we then cloned to our local disk so that we could edit: + + + +```bash +$ git remote -v +``` + +The above command will return output similar to the following: + +```bash +origin git@github.com:yourusername/developer.git (fetch) +origin git@github.com:yourusername/developer.git (push) +upstream https://github.com/fermyon/developer (fetch) +upstream https://github.com/fermyon/developer (push) +``` + +Once you are satisfied go ahead and push your changes: + + + +```bash +$ git push -u origin my_new_branch +``` + +### 11. Create a Pull Request + +If you return to your GitHub repository in your browser, you will notice that a PR has automatically been generated for you. + +Clicking on the green “Compare and pull request” button will allow you to add a title and description as part of the PR. + +![Compare and pull request](/static/image/compare_and_pull_request.png) + +You can also add any information in the textbox provided below the title. For example, screen captures and/or code/console/terminal snippets of your contribution working correctly and/or tests passing etc. + +Once you have finished creating your PR, please keep an eye on the PR; answering any questions as part of the collaboration process. + +**Thank You** + +Thanks for contributing. diff --git a/content/spin/v1/ai-sentiment-analysis-api-tutorial.md b/content/spin/v1/ai-sentiment-analysis-api-tutorial.md index a4b98ee5b..2ea3357cc 100644 --- a/content/spin/v1/ai-sentiment-analysis-api-tutorial.md +++ b/content/spin/v1/ai-sentiment-analysis-api-tutorial.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-09-05T09:00:00Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/ai-sentiment-analysis-api-tutorial" +canonical_url = "https://spinframework.dev/v2/ai-sentiment-analysis-api-tutorial" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/ai-sentiment-analysis-api-tutorial.md" --- @@ -32,7 +32,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/ai-sentime - [Conclusion](#conclusion) - [Next Steps](#next-steps) -> This tutorial does not work with Spin `v3.0` or above as the on disk representation of the models have changed. Refer to the [V3 tutorial](/spin/v3/ai-sentiment-analysis-api-tutorial) depending on your Spin version. +> This tutorial does not work with Spin `v3.0` or above as the on disk representation of the models have changed. Refer to the [V3 tutorial](https://spinframework.dev/v3/ai-sentiment-analysis-api-tutorial) depending on your Spin version. Artificial Intelligence (AI) Inferencing performs well on GPUs. However, GPU infrastructure is both scarce and expensive. This tutorial will show you how to use Fermyon Serverless AI to quickly build advanced AI-enabled serverless applications that can run on Fermyon Cloud. Your applications will benefit from 50 millisecond cold start times and operate 100x faster than other on-demand AI infrastructure services. Take a quick look at the video below to learn about executing inferencing on LLMs with no extra setup. diff --git a/content/spin/v1/api-guides-overview.md b/content/spin/v1/api-guides-overview.md index 16788d216..44dc39927 100644 --- a/content/spin/v1/api-guides-overview.md +++ b/content/spin/v1/api-guides-overview.md @@ -2,7 +2,7 @@ title = "API Support Overview" template = "spin_main" date = "2023-03-03T03:03:03Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/api-guides-overview" +canonical_url = "https://spinframework.dev/v2/api-guides-overview" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/api-guides-overview.md" --- diff --git a/content/spin/v1/build.md b/content/spin/v1/build.md index 400e4c8e7..1338c0703 100644 --- a/content/spin/v1/build.md +++ b/content/spin/v1/build.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/build" +canonical_url = "https://spinframework.dev/v2/build" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/build.md" --- diff --git a/content/spin/v1/cache.md b/content/spin/v1/cache.md index f303c68d8..03834fa0f 100644 --- a/content/spin/v1/cache.md +++ b/content/spin/v1/cache.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/cache" +canonical_url = "https://spinframework.dev/v2/cache" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/cache.md" --- diff --git a/content/spin/v1/cli-reference.md b/content/spin/v1/cli-reference.md index c8d35c298..2841df731 100644 --- a/content/spin/v1/cli-reference.md +++ b/content/spin/v1/cli-reference.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-01-01T00:00:01Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/cli-reference" +canonical_url = "https://spinframework.dev/v2/cli-reference" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/cli-reference.md" --- @@ -2483,7 +2483,7 @@ OPTIONS: {{ blockEnd }} -**Note:** For additional information, please see the [Managing Plugins](/spin/managing-plugins) and/or [Creating Plugins](/spin/plugin-authoring) sections of the documentation. +**Note:** For additional information, please see the [Managing Plugins](https://spinframework.dev/managing-plugins) and/or [Creating Plugins](https://spinframework.dev/plugin-authoring) sections of the documentation. ## spin registry @@ -3994,7 +3994,7 @@ OPTIONS: {{ blockEnd }} -**Note:** For additional information, please see the [Managing Templates](/spin/managing-templates) and/or [Creating Templates](/spin/template-authoring) sections of the documentation. +**Note:** For additional information, please see the [Managing Templates](https://spinframework.dev/managing-templates) and/or [Creating Templates](https://spinframework.dev/template-authoring) sections of the documentation. ## spin up diff --git a/content/spin/v1/contributing-docs.md b/content/spin/v1/contributing-docs.md index 2ce1542c1..456cb4620 100644 --- a/content/spin/v1/contributing-docs.md +++ b/content/spin/v1/contributing-docs.md @@ -2,7 +2,7 @@ title = "Contributing to Docs" template = "spin_main" date = "2022-01-01T00:00:01Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/contributing-docs" +canonical_url = "https://spinframework.dev/v2/contributing-docs" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/contributing-docs.md" keywords = "contribute contributing" @@ -54,7 +54,7 @@ How-to guides are oriented towards showing a user how to solve a problem, which ### 3. Reference -Reference resources are merely a dry description; describing the feature in its simplest form. A great example of a reference resource is the [Spin CLI Reference page](/spin/cli-reference). You will notice that the CLI Reference page simply lists all of the commands and available options. +Reference resources are merely a dry description; describing the feature in its simplest form. A great example of a reference resource is the [Spin CLI Reference page](https://spinframework.dev/cli-reference). You will notice that the CLI Reference page simply lists all of the commands and available options. ### 4. Explanation @@ -187,7 +187,7 @@ If you want the code in a code block to be copyable with no "smarts" to remove t **Multi-tab code blocks** -Multi-tab code blocks [have recently been implemented](https://github.com/fermyon/developer/pull/239). Examples can be seen in the [Spin](/spin/install#installing-spin) installer documentation and [Spin Key/Value documentation](/spin/key-value-store-tutorial#the-spin-toml-file). The above examples demonstrate how tabs can either represent platforms i.e. `Windows`, `Linux` and `macOS` or represent specific programming languages i.e. `Rust`, `JavaScript` and `Golang` etc. Here is a brief example of how to implement multi-tab code blocks when writing technical documentation for this site, using markdown. +Multi-tab code blocks [have recently been implemented](https://github.com/fermyon/developer/pull/239). Examples can be seen in the [Spin](https://spinframework.dev/install#installing-spin) installer documentation and [Spin Key/Value documentation](https://spinframework.dev/key-value-store-tutorial#the-spin-toml-file). The above examples demonstrate how tabs can either represent platforms i.e. `Windows`, `Linux` and `macOS` or represent specific programming languages i.e. `Rust`, `JavaScript` and `Golang` etc. Here is a brief example of how to implement multi-tab code blocks when writing technical documentation for this site, using markdown. The first step to implementing multi-tab code blocks is placing the `enable_shortcodes = true` configuration at the start of the `.md` file. Specifically, in the `.md` file's frontmatter. diff --git a/content/spin/v1/contributing-spin.md b/content/spin/v1/contributing-spin.md index 4e20ba976..bfb874e1b 100644 --- a/content/spin/v1/contributing-spin.md +++ b/content/spin/v1/contributing-spin.md @@ -2,7 +2,7 @@ title = "Contributing to Spin" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/contributing-spin" +canonical_url = "https://spinframework.dev/v2/contributing-spin" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/contributing-spin.md" --- diff --git a/content/spin/v1/deploying-to-fermyon.md b/content/spin/v1/deploying-to-fermyon.md index 9035add04..fa25b5718 100644 --- a/content/spin/v1/deploying-to-fermyon.md +++ b/content/spin/v1/deploying-to-fermyon.md @@ -2,7 +2,7 @@ title = "Deploying Spin Applications to Fermyon" template = "spin_main" date = "2022-05-20T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/deploying-to-fermyon" +canonical_url = "https://spinframework.dev/v2/deploying-to-fermyon" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/deploying-to-fermyon.md" --- diff --git a/content/spin/v1/distributing-apps.md b/content/spin/v1/distributing-apps.md index 9e293e09a..cb7095189 100644 --- a/content/spin/v1/distributing-apps.md +++ b/content/spin/v1/distributing-apps.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/distributing-apps" +canonical_url = "https://spinframework.dev/v2/distributing-apps" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/distributing-apps.md" --- diff --git a/content/spin/v1/dynamic-configuration.md b/content/spin/v1/dynamic-configuration.md index a1454aab7..cd9ddb2c6 100644 --- a/content/spin/v1/dynamic-configuration.md +++ b/content/spin/v1/dynamic-configuration.md @@ -2,7 +2,7 @@ title = "Dynamic and Runtime Application Configuration" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/dynamic-configuration" +canonical_url = "https://spinframework.dev/v2/dynamic-configuration" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/dynamic-configuration.md" --- diff --git a/content/spin/v1/extending-and-embedding.md b/content/spin/v1/extending-and-embedding.md index 9e28375ab..5001e46e5 100644 --- a/content/spin/v1/extending-and-embedding.md +++ b/content/spin/v1/extending-and-embedding.md @@ -2,7 +2,7 @@ title = "Extending and Embedding Spin" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/extending-and-embedding" +canonical_url = "https://spinframework.dev/v2/extending-and-embedding" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/extending-and-embedding.md" --- diff --git a/content/spin/v1/go-components.md b/content/spin/v1/go-components.md index f4a4cddfb..b599905b6 100644 --- a/content/spin/v1/go-components.md +++ b/content/spin/v1/go-components.md @@ -2,7 +2,7 @@ title = "Building Spin components in Go" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/go-components" +canonical_url = "https://spinframework.dev/v2/go-components" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/go-components.md" --- @@ -349,7 +349,7 @@ WASI can be used when implementing a Spin component. ## Storing Data in the Spin Key-Value Store -Spin has a key-value store built in. For information about using it from TinyGo, see [the key-value store tutorial](/spin/key-value-store-tutorial). +Spin has a key-value store built in. For information about using it from TinyGo, see [the key-value store tutorial](https://spinframework.dev/key-value-store-tutorial). ## Storing Data in SQLite diff --git a/content/spin/v1/http-outbound.md b/content/spin/v1/http-outbound.md index 08f3d06ad..19075bd48 100644 --- a/content/spin/v1/http-outbound.md +++ b/content/spin/v1/http-outbound.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/http-outbound" +canonical_url = "https://spinframework.dev/v2/http-outbound" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/http-outbound.md" --- diff --git a/content/spin/v1/http-trigger.md b/content/spin/v1/http-trigger.md index f6773c4ed..c55fbf0b0 100644 --- a/content/spin/v1/http-trigger.md +++ b/content/spin/v1/http-trigger.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/http-trigger" +canonical_url = "https://spinframework.dev/v2/http-trigger" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/http-trigger.md" --- diff --git a/content/spin/v1/index.md b/content/spin/v1/index.md index e8e942d85..435e00f7d 100644 --- a/content/spin/v1/index.md +++ b/content/spin/v1/index.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/index" +canonical_url = "https://spinframework.dev/v2/index" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/index.md" diff --git a/content/spin/v1/install.md b/content/spin/v1/install.md index cdac80796..be0b9737f 100644 --- a/content/spin/v1/install.md +++ b/content/spin/v1/install.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/install" +canonical_url = "https://spinframework.dev/v2/install" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/install.md" keywords = "install" diff --git a/content/spin/v1/javascript-components.md b/content/spin/v1/javascript-components.md index d64ae13ba..ac1b51e78 100644 --- a/content/spin/v1/javascript-components.md +++ b/content/spin/v1/javascript-components.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/javascript-components" +canonical_url = "https://spinframework.dev/v2/javascript-components" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/javascript-components.md" --- diff --git a/content/spin/v1/key-value-store-tutorial.md b/content/spin/v1/key-value-store-tutorial.md index 4dc35f347..fc8a58717 100644 --- a/content/spin/v1/key-value-store-tutorial.md +++ b/content/spin/v1/key-value-store-tutorial.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-02-21T00:00:00Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/key-value-store-tutorial" +canonical_url = "https://spinframework.dev/v2/key-value-store-tutorial" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/key-value-store-tutorial.md" --- diff --git a/content/spin/v1/kubernetes.md b/content/spin/v1/kubernetes.md index 5ff1458c5..0faaea1b0 100644 --- a/content/spin/v1/kubernetes.md +++ b/content/spin/v1/kubernetes.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-03-01T00:01:01Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/kubernetes" +canonical_url = "https://spinframework.dev/v2/kubernetes" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/kubernetes.md" --- diff --git a/content/spin/v1/kv-store-api-guide.md b/content/spin/v1/kv-store-api-guide.md index fbe7db781..5c966634a 100644 --- a/content/spin/v1/kv-store-api-guide.md +++ b/content/spin/v1/kv-store-api-guide.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-04-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/kv-store-api-guide" +canonical_url = "https://spinframework.dev/v2/kv-store-api-guide" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/kv-store-api-guide.md" --- diff --git a/content/spin/v1/language-support-overview.md b/content/spin/v1/language-support-overview.md index 2354f7e14..7b330f297 100644 --- a/content/spin/v1/language-support-overview.md +++ b/content/spin/v1/language-support-overview.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-01-01T00:00:01Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/language-support-overview" +canonical_url = "https://spinframework.dev/v2/language-support-overview" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/language-support-overview.md" --- diff --git a/content/spin/v1/managing-plugins.md b/content/spin/v1/managing-plugins.md index 4251c2664..82d21bb16 100644 --- a/content/spin/v1/managing-plugins.md +++ b/content/spin/v1/managing-plugins.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/managing-plugins" +canonical_url = "https://spinframework.dev/v2/managing-plugins" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/managing-plugins.md" --- diff --git a/content/spin/v1/managing-templates.md b/content/spin/v1/managing-templates.md index 18999f21f..351740f48 100644 --- a/content/spin/v1/managing-templates.md +++ b/content/spin/v1/managing-templates.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/managing-templates" +canonical_url = "https://spinframework.dev/v2/managing-templates" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/managing-templates.md" --- diff --git a/content/spin/v1/manifest-reference.md b/content/spin/v1/manifest-reference.md index ac19821cd..5c3ecaf93 100644 --- a/content/spin/v1/manifest-reference.md +++ b/content/spin/v1/manifest-reference.md @@ -2,7 +2,7 @@ title = "Spin Application Manifest Reference" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/manifest-reference" +canonical_url = "https://spinframework.dev/v2/manifest-reference" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/manifest-reference.md" --- diff --git a/content/spin/v1/other-languages.md b/content/spin/v1/other-languages.md index bd165802f..c4d27aec0 100644 --- a/content/spin/v1/other-languages.md +++ b/content/spin/v1/other-languages.md @@ -2,7 +2,7 @@ title = "Building Spin components in other languages" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/other-languages" +canonical_url = "https://spinframework.dev/v2/other-languages" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/other-languages.md" --- diff --git a/content/spin/v1/plugin-authoring.md b/content/spin/v1/plugin-authoring.md index 352de4259..2188527b2 100644 --- a/content/spin/v1/plugin-authoring.md +++ b/content/spin/v1/plugin-authoring.md @@ -2,7 +2,7 @@ title = "Creating Spin Plugins" template = "spin_main" date = "2023-02-1T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/plugin-authoring" +canonical_url = "https://spinframework.dev/v2/plugin-authoring" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/plugin-authoring.md" --- diff --git a/content/spin/v1/python-components.md b/content/spin/v1/python-components.md index 7b15944bf..06ff19d78 100644 --- a/content/spin/v1/python-components.md +++ b/content/spin/v1/python-components.md @@ -2,7 +2,7 @@ title = "Building Spin Components in Python" template = "spin_main" date = "2023-02-28T02:00:00Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/python-components" +canonical_url = "https://spinframework.dev/v2/python-components" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/python-components.md" --- diff --git a/content/spin/v1/quickstart.md b/content/spin/v1/quickstart.md index 563759022..d0da65f0b 100644 --- a/content/spin/v1/quickstart.md +++ b/content/spin/v1/quickstart.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/quickstart" +canonical_url = "https://spinframework.dev/v2/quickstart" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/quickstart.md" keywords = "quickstart" diff --git a/content/spin/v1/rdbms-storage.md b/content/spin/v1/rdbms-storage.md index a38950f34..3441d1138 100644 --- a/content/spin/v1/rdbms-storage.md +++ b/content/spin/v1/rdbms-storage.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/rdbms-storage" +canonical_url = "https://spinframework.dev/v2/rdbms-storage" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/rdbms-storage.md" --- diff --git a/content/spin/v1/redis-outbound.md b/content/spin/v1/redis-outbound.md index 8e83d96e9..d5ce857a2 100644 --- a/content/spin/v1/redis-outbound.md +++ b/content/spin/v1/redis-outbound.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/redis-outbound" +canonical_url = "https://spinframework.dev/v2/redis-outbound" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/redis-outbound.md" --- diff --git a/content/spin/v1/redis-trigger.md b/content/spin/v1/redis-trigger.md index 35b12ddbc..0f9212804 100644 --- a/content/spin/v1/redis-trigger.md +++ b/content/spin/v1/redis-trigger.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/redis-trigger" +canonical_url = "https://spinframework.dev/v2/redis-trigger" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/redis-trigger.md" --- diff --git a/content/spin/v1/registry-tutorial.md b/content/spin/v1/registry-tutorial.md index c7a1573e0..0edf9f19c 100644 --- a/content/spin/v1/registry-tutorial.md +++ b/content/spin/v1/registry-tutorial.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-02-13T00:00:00Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/registry-tutorial" +canonical_url = "https://spinframework.dev/v2/registry-tutorial" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/registry-tutorial.md" --- diff --git a/content/spin/v1/running-apps.md b/content/spin/v1/running-apps.md index c2a2311b9..3d364b7da 100644 --- a/content/spin/v1/running-apps.md +++ b/content/spin/v1/running-apps.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/running-apps" +canonical_url = "https://spinframework.dev/v2/running-apps" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/running-apps.md" --- diff --git a/content/spin/v1/rust-components.md b/content/spin/v1/rust-components.md index c1fc7a413..108962154 100644 --- a/content/spin/v1/rust-components.md +++ b/content/spin/v1/rust-components.md @@ -2,7 +2,7 @@ title = "Building Spin components in Rust" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/rust-components" +canonical_url = "https://spinframework.dev/v2/rust-components" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/rust-components.md" --- diff --git a/content/spin/v1/see-what-people-have-built-with-spin.md b/content/spin/v1/see-what-people-have-built-with-spin.md index 1f281b608..0a9b31c50 100644 --- a/content/spin/v1/see-what-people-have-built-with-spin.md +++ b/content/spin/v1/see-what-people-have-built-with-spin.md @@ -2,7 +2,7 @@ title = "Built With Spin" template = "spin_main" date = "2023-05-05T00:01:01Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/see-what-people-have-built-with-spin" +canonical_url = "https://spinframework.dev/v2/see-what-people-have-built-with-spin" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/see-what-people-have-built-with-spin.md" --- diff --git a/content/spin/v1/serverless-ai-api-guide.md b/content/spin/v1/serverless-ai-api-guide.md index ee66ef8e1..b36d6977c 100644 --- a/content/spin/v1/serverless-ai-api-guide.md +++ b/content/spin/v1/serverless-ai-api-guide.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-09-05T09:00:00Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/serverless-ai-api-guide" +canonical_url = "https://spinframework.dev/v2/serverless-ai-api-guide" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/serverless-ai-api-guide.md" --- diff --git a/content/spin/v1/serverless-ai-hello-world.md b/content/spin/v1/serverless-ai-hello-world.md index 484b843c1..7afb4e6f8 100644 --- a/content/spin/v1/serverless-ai-hello-world.md +++ b/content/spin/v1/serverless-ai-hello-world.md @@ -5,7 +5,7 @@ template = "spin_main" tags = ["ai", "serverless", "getting started"] enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/serverless-ai-hello-world" +canonical_url = "https://spinframework.dev/v2/serverless-ai-hello-world" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/serverless-ai-hello-world.md" --- @@ -316,7 +316,7 @@ $ spin build {{ blockEnd }} -Now that your app is built, there are three ways to test your Serverless AI app. One way to test the app is to run inferencing locally. This means running a LLM on your CPU. This is not as optimal compared to deploying to Fermyon’s Serverless AI, which uses high-powered GPUs in the cloud. To know more about this method, including downloading LLMs to your local machine, check out [the in-depth tutorial](../../spin/ai-sentiment-analysis-api-tutorial) on Building a Sentiment Analysis API using Serverless AI. +Now that your app is built, there are three ways to test your Serverless AI app. One way to test the app is to run inferencing locally. This means running a LLM on your CPU. This is not as optimal compared to deploying to Fermyon’s Serverless AI, which uses high-powered GPUs in the cloud. To know more about this method, including downloading LLMs to your local machine, check out [the in-depth tutorial](https://spinframework.dev/ai-sentiment-analysis-api-tutorial) on Building a Sentiment Analysis API using Serverless AI. Here are the two other methods for testing your app: @@ -378,8 +378,8 @@ hello-world: http://127.0.0.1:3000 (wildcard) This was just a small example of what Serverless AI Inferencing can do. To check out more detailed code samples: -- Read [our in-depth tutorial](../../spin/ai-sentiment-analysis-api-tutorial) on building a Sentiment Analysis API with Serverless AI -- Look at the [Serverless AI API Guide](../../spin/serverless-ai-api-guide) +- Read [our in-depth tutorial](https://spinframework.dev/ai-sentiment-analysis-api-tutorial) on building a Sentiment Analysis API with Serverless AI +- Look at the [Serverless AI API Guide](https://spinframework.dev/serverless-ai-api-guide) - Try the numerous Serverless AI examples in our GitHub repository called [ai-examples](https://github.com/fermyon/ai-examples). - [Contribute](../../hub/contributing) your Serverless AI app to our [Spin Hub](../../hub/index). - Ask questions and share your thoughts in [our Discord community](https://discord.gg/AAFNfS7NGf). diff --git a/content/spin/v1/spin-application-structure.md b/content/spin/v1/spin-application-structure.md index f803a45be..09c012255 100644 --- a/content/spin/v1/spin-application-structure.md +++ b/content/spin/v1/spin-application-structure.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-08-20T00:00:00Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/spin-application-structure" +canonical_url = "https://spinframework.dev/v2/spin-application-structure" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/spin-application-structure.md" keywords = "structure" diff --git a/content/spin/v1/sqlite-api-guide.md b/content/spin/v1/sqlite-api-guide.md index 64c706e18..78efc4400 100644 --- a/content/spin/v1/sqlite-api-guide.md +++ b/content/spin/v1/sqlite-api-guide.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-04-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/sqlite-api-guide" +canonical_url = "https://spinframework.dev/v2/sqlite-api-guide" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/sqlite-api-guide.md" --- diff --git a/content/spin/v1/template-authoring.md b/content/spin/v1/template-authoring.md index b1491ab43..b8e6ca4c7 100644 --- a/content/spin/v1/template-authoring.md +++ b/content/spin/v1/template-authoring.md @@ -2,7 +2,7 @@ title = "Creating Spin templates" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/template-authoring" +canonical_url = "https://spinframework.dev/v2/template-authoring" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/template-authoring.md" --- diff --git a/content/spin/v1/troubleshooting-application-dev.md b/content/spin/v1/troubleshooting-application-dev.md index 589422e28..ba4edc665 100644 --- a/content/spin/v1/troubleshooting-application-dev.md +++ b/content/spin/v1/troubleshooting-application-dev.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-02-13T00:00:00Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/troubleshooting-application-dev" +canonical_url = "https://spinframework.dev/v2/troubleshooting-application-dev" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/troubleshooting-application-dev.md" --- diff --git a/content/spin/v1/upgrade.md b/content/spin/v1/upgrade.md index bd8b55885..f0d4a0bc0 100644 --- a/content/spin/v1/upgrade.md +++ b/content/spin/v1/upgrade.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2023-05-01T00:01:01Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/upgrade" +canonical_url = "https://spinframework.dev/v2/upgrade" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/upgrade.md" --- diff --git a/content/spin/v1/url-shortener-tutorial.md b/content/spin/v1/url-shortener-tutorial.md index e44b3eaf5..0a53c7b69 100644 --- a/content/spin/v1/url-shortener-tutorial.md +++ b/content/spin/v1/url-shortener-tutorial.md @@ -2,7 +2,7 @@ title = "Building a URL Shortener With Spin" template = "spin_main" date = "2022-03-14T00:22:56Z" [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/url-shortener-tutorial" +canonical_url = "https://spinframework.dev/v2/url-shortener-tutorial" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/url-shortener-tutorial.md" --- diff --git a/content/spin/v1/variables.md b/content/spin/v1/variables.md index 945036d99..ddcb19c28 100644 --- a/content/spin/v1/variables.md +++ b/content/spin/v1/variables.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-06-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/variables" +canonical_url = "https://spinframework.dev/v2/variables" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/variables.md" --- diff --git a/content/spin/v1/writing-apps.md b/content/spin/v1/writing-apps.md index 542a49ba3..a19cda911 100644 --- a/content/spin/v1/writing-apps.md +++ b/content/spin/v1/writing-apps.md @@ -3,7 +3,7 @@ template = "spin_main" date = "2022-03-14T00:22:56Z" enable_shortcodes = true [extra] -canonical_url = "https://developer.fermyon.com/spin/v2/writing-apps" +canonical_url = "https://spinframework.dev/v2/writing-apps" url = "https://github.com/fermyon/developer/blob/main/content/spin/v1/writing-apps.md" --- diff --git a/content/spin/v2/ai-sentiment-analysis-api-tutorial.md b/content/spin/v2/ai-sentiment-analysis-api-tutorial.md index 8a9bc1552..678f1fb8b 100644 --- a/content/spin/v2/ai-sentiment-analysis-api-tutorial.md +++ b/content/spin/v2/ai-sentiment-analysis-api-tutorial.md @@ -31,7 +31,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/spin/v2/ai-sentime - [Conclusion](#conclusion) - [Next Steps](#next-steps) -> This tutorial does not work with Spin `v3.0` or above as the on disk representation of the models have changed. Refer to the [V3 tutorial](/spin/v3/ai-sentiment-analysis-api-tutorial) depending on your Spin version. +> This tutorial does not work with Spin `v3.0` or above as the on disk representation of the models have changed. Refer to the [V3 tutorial](https://spinframework.dev/v3/ai-sentiment-analysis-api-tutorial) depending on your Spin version. Artificial Intelligence (AI) Inferencing performs well on GPUs. However, GPU infrastructure is both scarce and expensive. This tutorial will show you how to use Fermyon Serverless AI to quickly build advanced AI-enabled serverless applications that can run on Fermyon Cloud. Your applications will benefit from 50 millisecond cold start times and operate 100x faster than other on-demand AI infrastructure services. Take a quick look at the video below to learn about executing inferencing on LLMs with no extra setup. diff --git a/content/spin/v2/cli-reference.md b/content/spin/v2/cli-reference.md index 208f67125..dbeb1610b 100644 --- a/content/spin/v2/cli-reference.md +++ b/content/spin/v2/cli-reference.md @@ -2972,7 +2972,7 @@ OPTIONS: {{ blockEnd }} -**Note:** For additional information, please see the [Managing Plugins](/spin/managing-plugins) and/or [Creating Plugins](/spin/plugin-authoring) sections of the documentation. +**Note:** For additional information, please see the [Managing Plugins](https://spinframework.dev/managing-plugins) and/or [Creating Plugins](https://spinframework.dev/plugin-authoring) sections of the documentation. ## spin registry @@ -4798,7 +4798,7 @@ OPTIONS: {{ blockEnd }} -**Note:** For additional information, please see the [Managing Templates](/spin/managing-templates) and/or [Creating Templates](/spin/template-authoring) sections of the documentation. +**Note:** For additional information, please see the [Managing Templates](https://spinframework.dev/managing-templates) and/or [Creating Templates](https://spinframework.dev/template-authoring) sections of the documentation. ## spin test diff --git a/content/spin/v2/triggers.md b/content/spin/v2/triggers.md index 17ee6ebf2..3f4c48b51 100644 --- a/content/spin/v2/triggers.md +++ b/content/spin/v2/triggers.md @@ -27,7 +27,7 @@ In Spin 2.2 and earlier, all triggers must be of the same type. For example, an In Spin 2.3 and later, an application can contain triggers of different types. For example, a single application can serve HTTP on one or more routes, and at the same time subscribe to one or more Redis pub-sub channels. -> If you're familiar with [Spin 1.x](/spin/manifest-reference-v1#the-trigger-table), note that [Spin 2 uses the term "trigger"](/spin/manifest-reference#the-trigger-table) to refer to each individual route or channel, rather than the trigger type. It's closer to the `[component.trigger]` usage than to the application trigger. +> If you're familiar with [Spin 1.x](https://spinframework.dev/manifest-reference-v1#the-trigger-table), note that [Spin 2 uses the term "trigger"](https://spinframework.dev/manifest-reference#the-trigger-table) to refer to each individual route or channel, rather than the trigger type. It's closer to the `[component.trigger]` usage than to the application trigger. ## Triggers and Components diff --git a/content/spin/v3/triggers.md b/content/spin/v3/triggers.md index 1b202356a..9e93913b4 100644 --- a/content/spin/v3/triggers.md +++ b/content/spin/v3/triggers.md @@ -27,7 +27,7 @@ In Spin 2.2 and earlier, all triggers must be of the same type. For example, an In Spin 2.3 and later, an application can contain triggers of different types. For example, a single application can serve HTTP on one or more routes, and at the same time subscribe to one or more Redis pub-sub channels. -> If you're familiar with [Spin 1.x](/spin/manifest-reference-v1#the-trigger-table), note that [Spin 2 uses the term "trigger"](/spin/manifest-reference#the-trigger-table) to refer to each individual route or channel, rather than the trigger type. It's closer to the `[component.trigger]` usage than to the application trigger. +> If you're familiar with [Spin 1.x](https://spinframework.dev/manifest-reference-v1#the-trigger-table), note that [Spin 2 uses the term "trigger"](https://spinframework.dev/manifest-reference#the-trigger-table) to refer to each individual route or channel, rather than the trigger type. It's closer to the `[component.trigger]` usage than to the application trigger. ## Triggers and Components diff --git a/content/spin/v3/variables.md b/content/spin/v3/variables.md index 97e50f4ca..57ca3ee57 100644 --- a/content/spin/v3/variables.md +++ b/content/spin/v3/variables.md @@ -295,4 +295,4 @@ If you run into the following error, you've most likely not configured the compo Handler returned an error: Error::Undefined("no variable for \"\".\"your-variable\"") ``` -To fix this, edit the `spin.toml` and add to the `[component..variables]` table a line such as ` = "{{ app-variable }}".` See [above](https://developer.fermyon.com/spin/v3/variables#adding-variables-to-your-applications) for more information. \ No newline at end of file +To fix this, edit the `spin.toml` and add to the `[component..variables]` table a line such as ` = "{{ app-variable }}".` See [above](https://spinframework.dev/v3/variables#adding-variables-to-your-applications) for more information. \ No newline at end of file diff --git a/content/wasm-functions/contributing-docs.md b/content/wasm-functions/contributing-docs.md index 3cafada4d..e465fb64a 100644 --- a/content/wasm-functions/contributing-docs.md +++ b/content/wasm-functions/contributing-docs.md @@ -1,7 +1,7 @@ title = "Contributing to Docs" template = "functions_main" date = "2022-01-01T00:00:01Z" -body_source = "/spin/v3/contributing-docs" +body_source = "/common/contributing-docs" [extra] url = "https://github.com/fermyon/developer/blob/main/content/wasm-functions/contributing-docs.md" diff --git a/content/wasm-functions/deploy.md b/content/wasm-functions/deploy.md index 210bd8971..69e763f5d 100644 --- a/content/wasm-functions/deploy.md +++ b/content/wasm-functions/deploy.md @@ -12,7 +12,7 @@ enable_shortcodes = true - [Specifying Variables](#specifying-variables) - [Next Steps](#next-steps) -This article will guide you through deploying a Spin Application to _Fermyon Wasm Functions_. You can deploy your [Spin App](/spin) in just a few steps. +This article will guide you through deploying a Spin Application to _Fermyon Wasm Functions_. You can deploy your [Spin App](https://spinframework.dev) in just a few steps. ## Prerequisites @@ -49,7 +49,7 @@ $ spin plugins update $ spin plugins upgrade aka ``` -You can learn more about managing Spin plugins in [this article](../spin/v3/managing-plugins.md). +You can learn more about managing Spin plugins in [this article](https://spinframework.dev/v3/managing-plugins.md). ## Log in to Fermyon Wasm Functions @@ -93,7 +93,7 @@ View application: https://c8769081-7ae5-4041-a10f-61d344a67da2.aka.fermyon.tec ### Specifying Variables -Spin supports [application variables](/spin/variables). Instead of being static, their values can be updated without modifying the application, creating a simpler experience for rotating secrets, updating API endpoints, and more. +Spin supports [application variables](https://spinframework.dev/variables). Instead of being static, their values can be updated without modifying the application, creating a simpler experience for rotating secrets, updating API endpoints, and more. For example, consider a Spin application with the following variable declaration as part of the application manifest (`spin.toml`): diff --git a/content/wasm-functions/faq.md b/content/wasm-functions/faq.md index 2ece1a6c8..e8cb19ba9 100644 --- a/content/wasm-functions/faq.md +++ b/content/wasm-functions/faq.md @@ -34,33 +34,33 @@ Fermyon Wasm Functions supports Spin CLI v0.6.0 or newer. That being said, there | Feature | Supported in Fermyon Wasm Functions? | | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- | | **Triggers** | -| [HTTP](https://developer.fermyon.com/spin/http-trigger) | Supported | -| [Redis](https://developer.fermyon.com/spin/redis-trigger) | Not supported | +| [HTTP](https://spinframework.dev/http-trigger) | Supported | +| [Redis](https://spinframework.dev/redis-trigger) | Not supported | | **APIs** | -| [Outbound HTTP](https://developer.fermyon.com/spin/v3/rust-components#sending-outbound-http-requests) | Supported | -| [Configuration Variables](https://developer.fermyon.com/spin/v3/variables) | Supported | -| [Key Value Storage](https://developer.fermyon.com/spin/v3/kv-store-api-guide) | Supported | -| [SQLite Storage](https://developer.fermyon.com/spin/sqlite-api-guide) | Not supported | -| [Serverless AI](https://developer.fermyon.com/spin/serverless-ai-api-guide) | [Limited Access](https://fibsu0jcu2g.typeform.com/to/dOFZ338a) | -| [Service Chaining](https://developer.fermyon.com/spin/http-outbound#local-service-chaining) | Supported | -| [MySQL](https://developer.fermyon.com/spin/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | -| [PostgreSQL](https://developer.fermyon.com/spin/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | -| [Outbound Redis](https://developer.fermyon.com/spin/rust-components#storing-data-in-redis-from-rust-components) | Supported | +| [Outbound HTTP](https://spinframework.dev/v3/rust-components#sending-outbound-http-requests) | Supported | +| [Configuration Variables](https://spinframework.dev/v3/variables) | Supported | +| [Key Value Storage](https://spinframework.dev/v3/kv-store-api-guide) | Supported | +| [SQLite Storage](https://spinframework.dev/sqlite-api-guide) | Not supported | +| [Serverless AI](https://spinframework.dev/serverless-ai-api-guide) | [Limited Access](https://fibsu0jcu2g.typeform.com/to/dOFZ338a) | +| [Service Chaining](https://spinframework.dev/http-outbound#local-service-chaining) | Supported | +| [MySQL](https://spinframework.dev/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | +| [PostgreSQL](https://spinframework.dev/rdbms-storage#using-mysql-and-postgresql-from-applications) | Supported | +| [Outbound Redis](https://spinframework.dev/rust-components#storing-data-in-redis-from-rust-components) | Supported | | [wasi-blobstore](https://github.com/WebAssembly/wasi-blobstore) | Not supported in Spin | | [wasi-config](https://github.com/WebAssembly/wasi-config) | Supported (2024-09-27 snapshot) | | [wasi-keyvalue](https://github.com/WebAssembly/wasi-keyvalue) | Supported (2024-10-17 snapshot) | | [wasi-messaging](https://github.com/WebAssembly/wasi-messaging) | Not supported in Spin | | **Features** | -| [Component dependencies](https://developer.fermyon.com/spin/v3/writing-apps#using-component-dependencies) | Supported | +| [Component dependencies](https://spinframework.dev/v3/writing-apps#using-component-dependencies) | Supported | | **Extensibility** | -| [Custom Triggers](https://developer.fermyon.com/spin/extending-and-embedding) | Not supported | +| [Custom Triggers](https://spinframework.dev/extending-and-embedding) | Not supported | -To learn more about what feature support looks like for various programming languages, visit the [Spin Language Support Guide](/spin/v3/language-support-overview). +To learn more about what feature support looks like for various programming languages, visit the [Spin Language Support Guide](https://spinframework.dev/v3/language-support-overview). ### Other Limitations - You cannot communicate between Spin applications using local name resolution -- [Runtime configuration](/spin/dynamic-configuration#runtime-configuration) is not supported at this time +- [Runtime configuration](https://spinframework.dev/dynamic-configuration#runtime-configuration) is not supported at this time ## Technical Frequently Asked Questions diff --git a/content/wasm-functions/github-actions.md b/content/wasm-functions/github-actions.md index 22771f0f2..e70837b08 100644 --- a/content/wasm-functions/github-actions.md +++ b/content/wasm-functions/github-actions.md @@ -161,7 +161,7 @@ Add any custom tooling you need to compile your project prior to calling `spin b ## Specifying Variables -Spin supports [application variables](/spin/variables). Instead of being static, their values can be +Spin supports [application variables](https://spinframework.dev/variables). Instead of being static, their values can be updated without modifying the application, creating a simpler experience for rotating secrets, updating API endpoints, and more. diff --git a/content/wasm-functions/index.md b/content/wasm-functions/index.md index c792c6765..894775402 100644 --- a/content/wasm-functions/index.md +++ b/content/wasm-functions/index.md @@ -7,13 +7,13 @@ url = "https://github.com/fermyon/a3000-docs/blob/main/content/wasm-functions/in --- -Fermyon Wasm Functions is a globally distributed PaaS (Platform-as-a-Service) running edge native applications with [Spin](/spin) on top of Akamai's Connected Cloud. It offers fast and resilient hosting for Spin applications. This means that Fermyon Wasm Functions is tailored towards hosting applications, which need fast execution, and availability in multiple regions across the World. +Fermyon Wasm Functions is a globally distributed PaaS (Platform-as-a-Service) running edge native applications with [Spin](https://spinframework.dev) on top of Akamai's Connected Cloud. It offers fast and resilient hosting for Spin applications. This means that Fermyon Wasm Functions is tailored towards hosting applications, which need fast execution, and availability in multiple regions across the World. Fermyon Wasm Functions does not require any operational effort on infrastructure from you as a user of the platform. Upon deploying a Spin application to the platform, the application is automatically distributed and made available in multiple regions within the service. A URL is provided for the application, which will persist across deployments. ![Architecture](/static/image/fwf-marketechture-sm.png) -In this documentation you can find resources that will help you [get started](./quickstart), showcase different types of applications and features you can take advantage of, explain core concepts, and provide help. If you are looking for information about building your first Spin application, start with the [Spin documentation](/spin). +In this documentation you can find resources that will help you [get started](./quickstart), showcase different types of applications and features you can take advantage of, explain core concepts, and provide help. If you are looking for information about building your first Spin application, start with the [Spin documentation](https://spinframework.dev). - [Application Deployment](#application-deployment) - [Traffic Routing](#traffic-routing) diff --git a/content/wasm-functions/old-data-redis.md b/content/wasm-functions/old-data-redis.md index 6df931d53..a18dc0d0c 100644 --- a/content/wasm-functions/old-data-redis.md +++ b/content/wasm-functions/old-data-redis.md @@ -27,7 +27,7 @@ First, you need to have Spin installed on your computer. Please use the official ## Using Spin Application Templates -The Spin CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](/wasm-functions/cli-reference#templates). For example: +The Spin CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](https://spinframework.dev/managing-templates). For example: @@ -59,7 +59,7 @@ The template we are interested in is `http-rust`. ## Creating Our New Spin Application -The official Spin CLI documentation also has instructions on how to [create a new Spin application](/wasm-functions/cli-reference#new). Let's go ahead and create a new `http-rust` application: +The official Spin CLI documentation also has instructions on how to [create a new Spin application](https://spinframework.dev/quickstart). Let's go ahead and create a new `http-rust` application: diff --git a/content/wasm-functions/old-develop.md b/content/wasm-functions/old-develop.md index 651199326..a3af55371 100644 --- a/content/wasm-functions/old-develop.md +++ b/content/wasm-functions/old-develop.md @@ -15,7 +15,7 @@ url = "https://github.com/fermyon/developer/blob/main/content/cloud/develop.md" - [Run the Application](#run-the-application) - [Next Steps](#next-steps) -This article briefly describes how to create a new Spin application. For a more thorough guide to developing Spin applications, take a look [here](/spin/writing-apps). +This article briefly describes how to create a new Spin application. For a more thorough guide to developing Spin applications, take a look [here](https://spinframework.dev/writing-apps). ## Prerequisites - Install the Spin CLI @@ -192,7 +192,7 @@ You'll need the `wasm32-wasi` target for Rust: $ rustup target add wasm32-wasi ``` -[Learn more in the language guide.](/spin/rust-components) +[Learn more in the language guide.](https://spinframework.dev/rust-components) {{ blockEnd }} @@ -207,7 +207,7 @@ $ spin plugins update $ spin plugins install js2wasm --yes ``` -[Learn more in the language guide.](/spin/javascript-components) +[Learn more in the language guide.](https://spinframework.dev/javascript-components) {{ blockEnd }} @@ -292,7 +292,7 @@ From here the app is ready to build and run: $ spin build --up ``` -[Learn more in the language guide.](/spin/python-components) +[Learn more in the language guide.](https://spinframework.dev/python-components) {{ blockEnd }} @@ -300,7 +300,7 @@ $ spin build --up You'll need the TinyGo compiler, as the standard Go compiler does not yet support the WASI standard. See the [TinyGo installation guide](https://tinygo.org/getting-started/install/). -[Learn more in the language guide.](/spin/go-components) +[Learn more in the language guide.](https://spinframework.dev/go-components) {{ blockEnd }} @@ -637,4 +637,4 @@ Hello, Fermyon ## Next Steps - Learn how to [deploy an application](deploy) -- To learn more about how to develop Spin applications, head over to the [Spin documentation](/spin) \ No newline at end of file +- To learn more about how to develop Spin applications, head over to the [Spin documentation](https://spinframework.dev) \ No newline at end of file diff --git a/content/wasm-functions/querying-linode-mysql.md b/content/wasm-functions/querying-linode-mysql.md index 4759d3077..2418ce28a 100644 --- a/content/wasm-functions/querying-linode-mysql.md +++ b/content/wasm-functions/querying-linode-mysql.md @@ -91,11 +91,11 @@ First, you need to have the `spin` CLI and the `aka` plugin installed on your co ## Using Spin Application Templates -The `spin` CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](/spin/v3/managing-templates). The template we are interested in, for this tutorial, is the `http-ts` template. +The `spin` CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](https://spinframework.dev/v3/managing-templates). The template we are interested in, for this tutorial, is the `http-ts` template. ## Creating Our New Spin Application -The official `spin` CLI documentation also has instructions on how to [create a new Spin application](/spin/v3/writing-apps#creating-an-application-from-a-template), from an existing template. Using the docs as a reference, we can create a new Spin application based on the `http-ts` template, move into the application directory and install its dependencies as shown here: +The official `spin` CLI documentation also has instructions on how to [create a new Spin application](https://spinframework.dev/v3/writing-apps#creating-an-application-from-a-template), from an existing template. Using the docs as a reference, we can create a new Spin application based on the `http-ts` template, move into the application directory and install its dependencies as shown here: @@ -109,7 +109,7 @@ $ npm install ## Configuration -Open the Spin application's `spin.toml` file, add a set of application variables and link them to the `linode-mysql` component. This allows modifying the connection string for the MySQL database without changing the actual source code. Consult the Spin documentation to learn more about [using variables in Spin](/spin/v3/variables). +Open the Spin application's `spin.toml` file, add a set of application variables and link them to the `linode-mysql` component. This allows modifying the connection string for the MySQL database without changing the actual source code. Consult the Spin documentation to learn more about [using variables in Spin](https://spinframework.dev/v3/variables). ```toml [variables] diff --git a/content/wasm-functions/querying-postgresql.md b/content/wasm-functions/querying-postgresql.md index c62bb4979..fd10a6f0a 100644 --- a/content/wasm-functions/querying-postgresql.md +++ b/content/wasm-functions/querying-postgresql.md @@ -64,11 +64,11 @@ First, you need to have `spin` CLI installed on your computer. Please use the of ## Using Spin Application Templates -The `spin` CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](/spin/v3/managing-templates). The template we are interested in, for this tutorial, is the `http-js` template. +The `spin` CLI facilitates the creation of new Spin applications through the use of application templates. You can install Spin application templates using the [official Spin CLI documentation](https://spinframework.dev/v3/managing-templates). The template we are interested in, for this tutorial, is the `http-js` template. ## Creating Our New Spin Application -The official `spin` CLI documentation also has instructions on how to [create a new Spin application](/spin/v3/writing-apps#creating-an-application-from-a-template), from an existing template. Using the docs as a reference, we can create a new Spin application based on the `http-js` template, move into the application directory and install its dependencies as shown here: +The official `spin` CLI documentation also has instructions on how to [create a new Spin application](https://spinframework.dev/v3/writing-apps#creating-an-application-from-a-template), from an existing template. Using the docs as a reference, we can create a new Spin application based on the `http-js` template, move into the application directory and install its dependencies as shown here: @@ -82,7 +82,7 @@ $ npm install ## Configuration -Open the Spin application's `spin.toml` file, add an application variable and link it to the `hello-postgresql` component. This allows modifying the connection string for PostgreSQL without changing the actual source code. Consult the Spin documentation to learn more about [using variables in Spin](/spin/v3/variables). +Open the Spin application's `spin.toml` file, add an application variable and link it to the `hello-postgresql` component. This allows modifying the connection string for PostgreSQL without changing the actual source code. Consult the Spin documentation to learn more about [using variables in Spin](https://spinframework.dev/v3/variables). diff --git a/content/wasm-functions/quickstart.md b/content/wasm-functions/quickstart.md index 696f804bd..e1a0c3cdb 100644 --- a/content/wasm-functions/quickstart.md +++ b/content/wasm-functions/quickstart.md @@ -19,11 +19,11 @@ url = "https://github.com/fermyon/developer/blob/main/content/wasm-functions/qui > This quickstart requires access to the public preview of Fermyon Wasm Functions. If you haven’t already requested access, please do so first by completing [this short form](https://fibsu0jcu2g.typeform.com/fwf-preview). The Fermyon team will review your request and follow up shortly. -Fermyon Wasm Functions is the platform for running [Spin](/spin) applications inside of the Akamai Connected Cloud. For more details on limitations and support policy, check out the [FAQ](faq.md). +Fermyon Wasm Functions is the platform for running [Spin](https://spinframework.dev) applications inside of the Akamai Connected Cloud. For more details on limitations and support policy, check out the [FAQ](faq.md). ![Developer Workflow](/static/image/devx-workflow-fermyon-on-akamai.png) -This guide will get you up and running with Fermyon Wasm Functions in less than two minutes. To do so, we've already made a [Spin](/spin) application ready for you to deploy to Fermyon Wasm Functions. +This guide will get you up and running with Fermyon Wasm Functions in less than two minutes. To do so, we've already made a [Spin](https://spinframework.dev) application ready for you to deploy to Fermyon Wasm Functions. @@ -79,7 +79,7 @@ Unzip the binary release and place the `spin.exe` in your system path. {{ blockEnd }} -{{ details "Learn more" "[Spin](https://github.com/fermyon/spin) is an open-source project used for creating, developing, building, running, and deploying Spin applications. It is both a CLI tool and a runtime, and provides SDKs for a variety of programming languages, including, but not limited to, Rust, TinyGo, and C#. \n\n The Spin project provides installers that are supported on Linux (amd64), macOS (amd64 and arm64), and Windows(amd64). \n\n The [Spin](/spin) documentation is a good starting place to learn more about using the framework to develop applications."}} +{{ details "Learn more" "[Spin](https://github.com/fermyon/spin) is an open-source project used for creating, developing, building, running, and deploying Spin applications. It is both a CLI tool and a runtime, and provides SDKs for a variety of programming languages, including, but not limited to, Rust, TinyGo, and C#. \n\n The Spin project provides installers that are supported on Linux (amd64), macOS (amd64 and arm64), and Windows(amd64). \n\n The [Spin](https://spinframework.dev) documentation is a good starting place to learn more about using the framework to develop applications."}} ## Install the `aka` Plugin for Spin @@ -151,7 +151,7 @@ You'll need the TinyGo compiler, as the standard Go compiler does not yet suppor ## Create a New Spin Application -Next we'll prepare an application with Spin. You can [write an app from scratch](../spin/v3/writing-apps) or use an existing template. The Spin Hub has many reference examples and templates: +Next we'll prepare an application with Spin. You can [write an app from scratch](https://spinframework.dev/v3/writing-apps) or use an existing template. The Spin Hub has many reference examples and templates:
{{suh_cards}} diff --git a/content/wasm-functions/using-key-value-store.md b/content/wasm-functions/using-key-value-store.md index 483b18125..8b3ae69aa 100644 --- a/content/wasm-functions/using-key-value-store.md +++ b/content/wasm-functions/using-key-value-store.md @@ -13,7 +13,7 @@ enable_shortcodes = true - [Deploying to Fermyon Wasm Functions](#deploying-to-fermyon-wasm-functions) - [Next Steps](#next-steps) -With Spin Key Value Store support in _Fermyon Wasm Functions_, you can persist non-relational data generated by your [Spin](/spin) application across application restarts and updates. _Fermyon Wasm Functions_ will provision and manage the key value store on your behalf, handling the heavy lifting for you. Spin Key Value Stores are isolated to a single application, and components cannot access the store unless explicitly granted permission. This capabilities-based security model ensures that only authorized components can interact with the data. To learn more about the Spin Key Value Store SDK, please visit the [API guide](/spin/v3/kv-store-api-guide). +With Spin Key Value Store support in _Fermyon Wasm Functions_, you can persist non-relational data generated by your [Spin](https://spinframework.dev) application across application restarts and updates. _Fermyon Wasm Functions_ will provision and manage the key value store on your behalf, handling the heavy lifting for you. Spin Key Value Stores are isolated to a single application, and components cannot access the store unless explicitly granted permission. This capabilities-based security model ensures that only authorized components can interact with the data. To learn more about the Spin Key Value Store SDK, please visit the [API guide](https://spinframework.dev/v3/kv-store-api-guide). As part of this tutorial, we will build a Spin application which leverages the Key Value Store provided by _Fermyon Wasm Functions_ for persistence. Once we have finished implementing the Spin app, we will run it locally using `spin up` for testing purposes, before we deploy it to _Fermyon Wasm Functions_ using the `spin aka deploy` command. @@ -45,7 +45,7 @@ $ npm install ## Grant Key Value Store Permission -To enable a component in Spin to use a key value store, you need to [grant it the necessary permissions in the application's manifest](/spin/kv-store-api-guide#granting-key-value-store-permissions-to-components) (`spin.toml`) by adding a key-value store label. This both grants the component access to the key value store and signals _Fermyon Wasm Functions_ (FWF) to provision one for the application. In this tutorial, we’ll use the label "default", but you can choose any label that works best for you. +To enable a component in Spin to use a key value store, you need to [grant it the necessary permissions in the application's manifest](https://spinframework.dev/kv-store-api-guide#granting-key-value-store-permissions-to-components) (`spin.toml`) by adding a key-value store label. This both grants the component access to the key value store and signals _Fermyon Wasm Functions_ (FWF) to provision one for the application. In this tutorial, we’ll use the label "default", but you can choose any label that works best for you. ```toml [component.hello-key-value-store] diff --git a/content/wasm-languages/CONTRIBUTING.md b/content/wasm-languages/CONTRIBUTING.md index d88db1bd2..a03ebf7e8 100644 --- a/content/wasm-languages/CONTRIBUTING.md +++ b/content/wasm-languages/CONTRIBUTING.md @@ -56,4 +56,4 @@ The contents of this repository are licensed under the [Creative Commons 4.0 Att ## Contributing Guide -To learn more about formatting options, testing your new content, previewing your contributions locally before submitting etc. read the [Contributing guide](../spin/v2/contributing-docs). +To learn more about formatting options, testing your new content, previewing your contributions locally before submitting etc. read the [Contributing guide](/contributing-docs). diff --git a/content/wasm-languages/about-examples.md b/content/wasm-languages/about-examples.md index c6e1e4a71..ae1ae12d1 100644 --- a/content/wasm-languages/about-examples.md +++ b/content/wasm-languages/about-examples.md @@ -84,7 +84,7 @@ command = "cargo build --target wasm32-wasi --release" watch = ["src/**/*.rs", "Cargo.toml"] ``` -The format and fields are defined in the [official Spin configuration docs](../spin/v2/manifest-reference). +The format and fields are defined in the [official Spin configuration docs](https://spinframework.dev/v2/manifest-reference). The command to build and start a Spin application is `spin build --up`. This will typically start a server on `http://localhost:3000` unless you specify otherwise. diff --git a/content/wasm-languages/go-lang.md b/content/wasm-languages/go-lang.md index c19827a5c..47aee9af9 100644 --- a/content/wasm-languages/go-lang.md +++ b/content/wasm-languages/go-lang.md @@ -122,6 +122,6 @@ Hello, World! Here are some great resources: - TinyGo has [a step-by-step walkthrough](https://tinygo.org/docs/guides/webassembly/) for building and running Go WebAssembly modules -- There are [instructions](https://developer.fermyon.com/spin/go-components/) and [examples](https://github.com/spinframework/spin-go-sdk/tree/main/examples) +- There are [instructions](https://spinframework.dev/go-components/) and [examples](https://github.com/spinframework/spin-go-sdk/tree/main/examples) - Get started quickly with Spin templates for Go: e.g. `spin templates list --tag go` and `spin new -t http-go` - A [short article](https://golangbot.com/webassembly-using-go/) on compiling to Go's "JS/Wasm" target \ No newline at end of file diff --git a/content/wasm-languages/javascript.md b/content/wasm-languages/javascript.md index 3005d7d25..e94ad7372 100644 --- a/content/wasm-languages/javascript.md +++ b/content/wasm-languages/javascript.md @@ -35,7 +35,7 @@ The Spin SDK makes it very easy to build Javascript/TypeScript Wasm applications ### Prerequisites -If you have not done so already, please [install Spin](/spin/v3/install). Having Spin installed will allow us to easily use Spin application templates. +If you have not done so already, please [install Spin](https://spinframework.dev/v3/install). Having Spin installed will allow us to easily use Spin application templates. ### The Spin JS/TS SDK Template diff --git a/content/wasm-languages/python.md b/content/wasm-languages/python.md index 19c6c48a9..12057ffbb 100644 --- a/content/wasm-languages/python.md +++ b/content/wasm-languages/python.md @@ -57,7 +57,7 @@ Installed 1 template(s) +---------------------------------------------+ ``` -**Please note:** For more information about managing `spin templates`, see the [templates section](../spin/v2/cli-reference#spin-templates) in the Spin Command Line Interface (CLI) documentation. +**Please note:** For more information about managing `spin templates`, see the [templates section](https://spinframework.dev/managing-templates) in the Spin Command Line Interface (CLI) documentation. ## Example @@ -176,7 +176,7 @@ Joel's video on Spin, Python, and Components (Recorded at WasmCon on Sep 12, 202 Here are some great resources: - A tutorial for building [Python Wasm apps with Spin](https://dev.to/technosophos/building-a-serverless-webassembly-app-with-spin-5dh9) - The [Spin Python SDK](https://github.com/spinframework/spin-python-sdk) -- The [Spin Developer Docs](../spin) fully document the Python SDKs +- The [Spin Developer Docs](https://spinframework.dev) fully document the Python SDKs - [Python Wasm examples](../../hub/index) at Spin Hub - The [Componentize-Py](https://pypi.org/project/componentize-py/) tooling - VMware has a [distribution of CPython as Wasm](https://github.com/vmware-labs/webassembly-language-runtimes/tree/main/python) based on the official CPython diff --git a/content/wasm-languages/rust.md b/content/wasm-languages/rust.md index ee1f03f4f..b7c7600f1 100644 --- a/content/wasm-languages/rust.md +++ b/content/wasm-languages/rust.md @@ -127,11 +127,11 @@ From there, running the app is as easy as `spin up`! Here are some great resources: -- The official [documentation for Spin](https://developer.fermyon.com/spin/rust-components/) has many examples, including creating Redis listeners. +- The official [documentation for Spin](https://spinframework.dev/rust-components/) has many examples, including creating Redis listeners. - Rust has a [dedicated mini-site covering WebAssembly](https://www.rust-lang.org/what/wasm) - The Rust Linz group did a [presentation on Rust and Wagi](https://www.youtube.com/watch?v=9NDwHBjLlhQ) and posted a GitHub [repo full of Wagi examples](https://github.com/rstropek/rust-samples) - [Wasmtime](https://wasmtime.dev/) is the reference implementation of Wasm32-WASI. - [egui](https://www.egui.rs/) provides a GUI toolkit that can be compiled into Wasm and run in the browser - There are several rich examples in the [Spin Rust SDK repo](https://github.com/spinframework/spin-rust-sdk/tree/stable/examples) as well as the [Spin Up Hub](https://developer.fermyon.com/hub) - The [Bartholomew CMS](https://github.com/fermyon/bartholomew) is written in Rust and runs in Spin -- The [spin-fileserver](https://github.com/fermyon/spin-fileserver) is a simple Rust Spin-native app +- The [spin-fileserver](https://github.com/spinframework/spin-fileserver) is a simple Rust Spin-native app diff --git a/content/wasm-languages/standards.md b/content/wasm-languages/standards.md index 969e4f9cc..08f46a9fe 100644 --- a/content/wasm-languages/standards.md +++ b/content/wasm-languages/standards.md @@ -46,7 +46,7 @@ DeisLabs (at Microsoft) proposed Wagi based on the CGI 1.1 specification. - The architecture document is [in the Wagi server repo](https://github.com/deislabs/wagi/blob/main/docs/architecture.md) - The description of the [environment variables](https://github.com/deislabs/wagi/blob/main/docs/environment_variables.md) -- Spin's [Wagi support](../spin/v2/http-trigger) +- Spin's [Wagi support](https://spinframework.dev/v2/http-trigger) ## Spin Improvement Proposals (SIPs) diff --git a/content/wasm-languages/zig.md b/content/wasm-languages/zig.md index f3b22e24b..d75b416bb 100644 --- a/content/wasm-languages/zig.md +++ b/content/wasm-languages/zig.md @@ -35,9 +35,9 @@ Things we're not big fans of: # Examples ->> All of our examples follow [a documented pattern using common tools](/wasm-languages/about-examples). In these examples, we initially run our applications using the [wasmtime](https://github.com/bytecodealliance/wasmtime) runtime and then progress and demonstrate how to run Zig applications using the [Spin framework](../spin/v2/index). +>> All of our examples follow [a documented pattern using common tools](/wasm-languages/about-examples). In these examples, we initially run our applications using the [wasmtime](https://github.com/bytecodealliance/wasmtime) runtime and then progress and demonstrate how to run Zig applications using the [Spin framework](https://spinframework.dev/v2/index). -You must have [Zig](https://ziglang.org/learn/) installed. If you haven't already done so, please also go ahead and [install Spin](../spin/v2/install). +You must have [Zig](https://ziglang.org/learn/) installed. If you haven't already done so, please also go ahead and [install Spin](https://spinframework.dev/v2/install). ## Example 1 @@ -88,7 +88,7 @@ $ wasmtime src/main.wasm 123 hello ## Example 2 -In this example we are going to build a "hello world" WAGI application using Zig. We will then run the Wasm binary with wasmtime to view the output in the console, and then run it again as a [Spin](../spin/v2/index) application served over HTTP. +In this example we are going to build a "hello world" WAGI application using Zig. We will then run the Wasm binary with wasmtime to view the output in the console, and then run it again as a [Spin](https://spinframework.dev/v2/index) application served over HTTP. Create a new Zig program: diff --git a/downloads/install.sh b/downloads/install.sh index f6b2f4506..468907c50 100755 --- a/downloads/install.sh +++ b/downloads/install.sh @@ -110,7 +110,7 @@ case $OSTYPE in ;; *) fancy_print 1 "The OSTYPE: ${OSTYPE} is not supported by this script." - fancy_print 2 "Please refer to this article to install Spin: https://developer.fermyon.com/spin/quickstart" + fancy_print 2 "Please refer to this article to install Spin: https://spinframework.dev/quickstart" exit 1 ;; esac @@ -181,5 +181,5 @@ else fancy_print 0 "Step 5: Skipping plugin installation for OS with musl" fi # Direct to quicks-start doc -fancy_print 0 "You're good to go. Check here for the next steps: https://developer.fermyon.com/spin/quickstart" +fancy_print 0 "You're good to go. Check here for the next steps: https://spinframework.dev/quickstart" fancy_print 0 "Run './spin' to get started" diff --git a/spin-up-hub/src/components/FermyonCloudModal.vue b/spin-up-hub/src/components/FermyonCloudModal.vue index d856664ca..f1d76ec2c 100644 --- a/spin-up-hub/src/components/FermyonCloudModal.vue +++ b/spin-up-hub/src/components/FermyonCloudModal.vue @@ -64,7 +64,7 @@ export default {
Before You Deploy
- You’ll need to install Spin - our open source developer tool - and have a + You’ll need to install Spin - our open source developer tool - and have a Fermyon Cloud account (free) to deploy the application to.
diff --git a/templates/cloud_sidebar.hbs b/templates/cloud_sidebar.hbs index e096e89db..1ed603186 100644 --- a/templates/cloud_sidebar.hbs +++ b/templates/cloud_sidebar.hbs @@ -87,8 +87,6 @@
  • REST API
    • -
  • Spin CLI Reference
  • Cloud Command Reference
    • diff --git a/templates/common_sidebar.hbs b/templates/common_sidebar.hbs index a5ae4921f..30ee8c529 100644 --- a/templates/common_sidebar.hbs +++ b/templates/common_sidebar.hbs @@ -13,7 +13,7 @@ References

    diff --git a/templates/content_navbar.hbs b/templates/content_navbar.hbs index 222e79064..2bdfa0a2c 100644 --- a/templates/content_navbar.hbs +++ b/templates/content_navbar.hbs @@ -215,7 +215,7 @@ Star - + Spin Quickstart {{/if}} @@ -226,7 +226,7 @@ Star - + Spin Quickstart {{/if}} diff --git a/toolkit/README.md b/toolkit/README.md index 190426e96..7a878d4bd 100644 --- a/toolkit/README.md +++ b/toolkit/README.md @@ -10,7 +10,7 @@ # Supporting Documentation -If you are using this toolkit to add/edit the current documentation, please read the [contributing documentation](https://developer.fermyon.com/spin/v2/contributing-docs) page (and perhaps leave it open for reference when forking, cloning, committing, etc.). +If you are using this toolkit to add/edit the current documentation, please read the [contributing documentation](https://spinframework.dev/v2/contributing-docs) page (and perhaps leave it open for reference when forking, cloning, committing, etc.). # Developer Repository Location @@ -43,7 +43,7 @@ curl --version # Write Codeblocks -The `update_spin_cli_reference.py` script will fetch the current [Spin CLI Reference](https://developer.fermyon.com/spin/v2/cli-reference) document from the web and write a fresh copy of the source markdown file (a new file called `updated_markdown.md` with the new version of code blocks added). The fresh markdown file, generated by this script, is the basis of a PR that contains the CLI commands for the new version of Spin. +The `update_spin_cli_reference.py` script will fetch the current [Spin CLI Reference](https://spinframework.dev/v2/cli-reference) document from the web and write a fresh copy of the source markdown file (a new file called `updated_markdown.md` with the new version of code blocks added). The fresh markdown file, generated by this script, is the basis of a PR that contains the CLI commands for the new version of Spin. ## Install Python Dependencies diff --git a/toolkit/update_spin_cli_reference.py b/toolkit/update_spin_cli_reference.py index d131fcb08..4ad7919e8 100644 --- a/toolkit/update_spin_cli_reference.py +++ b/toolkit/update_spin_cli_reference.py @@ -1,7 +1,7 @@ import requests import sys # Import sys to access command line arguments -url = "https://raw.githubusercontent.com/fermyon/developer/main/content/spin/v2/cli-reference.md" +url = "https://raw.githubusercontent.com/spinframework/spin-docs/main/content/v2/cli-reference.md" def download_markdown(url): response = requests.get(url)