A new open source project that streamlines the experience of developing, deploying, and operating Wasm workloads on Kubernetes.
9 | {{< blocks/link-down color="info" >}} 10 | {{< /blocks/cover >}} 11 | 12 | 13 | {{% blocks/lead color="primary" %}} 14 | 15 | SpinKube comprises the following open source projects. 16 | 17 |18 | 19 | **Containerd Shim Spin** 20 | 21 | The [Containerd Shim Spin repository](https://github.com/spinframework/containerd-shim-spin) provides 22 | shim implementations for running WebAssembly ([Wasm](https://webassembly.org/)) / Wasm System 23 | Interface ([WASI](https://github.com/WebAssembly/WASI)) workloads using 24 | [runwasi](https://github.com/deislabs/runwasi) as a library, whereby workloads built using the [Spin 25 | framework](https://github.com/fermyon/spin) can function similarly to container workloads in a 26 | Kubernetes environment. 27 | 28 |
29 | 30 | **Runtime Class Manager** 31 | 32 | The [Runtime Class Manager, also known as the Containerd Shim Lifecycle 33 | Operator](https://github.com/spinframework/runtime-class-manager), is designed to automate and manage the 34 | lifecycle of containerd shims in a Kubernetes environment. This includes tasks like installation, 35 | update, removal, and configuration of shims, reducing manual errors and improving reliability in 36 | managing WebAssembly (Wasm) workloads and other containerd extensions. 37 | 38 |
39 | 40 | **Spin Plugin for Kubernetes** 41 | 42 | The [Spin plugin for Kubernetes](https://github.com/spinframework/spin-plugin-kube), known as `spin 43 | kube`, faciliates the translation of existing [Spin 44 | applications](https://developer.fermyon.com/spin) into the Kubernetes custom resource that will be 45 | deployed and managed on your cluster. This plugin works by taking your spin application manifest and 46 | scaffolding it into a Kubernetes yaml, which can be deployed and managed with `kubectl`. This allows 47 | Kubernetes to manage and run Wasm workloads in a way similar to traditional container workloads. 48 | 49 |
50 | 51 | **Spin Operator** 52 | 53 | The [Spin Operator](https://github.com/spinframework/spin-operator/) enables deploying Spin applications 54 | to Kubernetes. The foundation of this project is built using the 55 | [kubebuilder](https://github.com/kubernetes-sigs/kubebuilder) framework. Spin Operator defines Spin 56 | App Custom Resource Definitions (CRDs). Spin Operator watches SpinApp Custom Resources e.g. Spin app 57 | image, replicas, schedulers and other user-defined values and realizes the desired state in the 58 | Kubernetes cluster. Spin Operator introduces a host of functionality such as resource-based scaling, 59 | event-driven scaling, and much more. 60 | 61 | {{% /blocks/lead %}} 62 | -------------------------------------------------------------------------------- /assets/scss/_variables_project.scss: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Add styles or override variables from the theme here. 4 | 5 | */ 6 | 7 | $td-enable-google-fonts: true; 8 | $google_font_name: "Work Sans"; 9 | $google_font_family: "Work+Sans:300,300i,400,400i,700,700i"; 10 | 11 | 12 | /* Colors */ 13 | // $primary: #231F21; 14 | $primary: #0E092D; 15 | $secondary: #F8EFFD; 16 | 17 | $spkb-purple: #9A51FF; 18 | $spkb-blue: #4140F3; 19 | $spkb-bg: #F8EFFD; 20 | 21 | 22 | .article-meta, 23 | .feedback--title { 24 | margin-top: 3.67rem; 25 | } 26 | 27 | .td-navbar { 28 | .navbar-brand__name { 29 | display: none; 30 | } 31 | 32 | .navbar-brand { 33 | svg { 34 | height: 60px !important; 35 | width: auto !important; 36 | } 37 | } 38 | 39 | .navbar-brand__logo { 40 | 41 | } 42 | 43 | .nav-link { 44 | color: lighten($spkb-purple, 15%); 45 | padding: 0.425rem 0.75rem !important; 46 | border-radius: 0.5rem; 47 | font-weight: 600 !important; 48 | 49 | &:hover { 50 | color: lighten($spkb-blue, 27.5%); 51 | } 52 | &.active { 53 | color: lighten($spkb-blue, 27.5%) !important; 54 | background-color: rgba($spkb-purple, 0.25); 55 | } 56 | } 57 | 58 | .td-search__input { 59 | // border: 1px solid $spkb-purple; 60 | background-color: lighten($primary, 8.5%) !important; 61 | 62 | &:hover, &:active, &:focus { 63 | color: white !important; 64 | } 65 | } 66 | } 67 | 68 | .td-sidebar { 69 | padding-top: 5.5rem !important; 70 | } 71 | .td-sidebar-toc, 72 | .td-main main { 73 | padding-top: 7rem !important; 74 | } 75 | 76 | .td-sidebar { 77 | h1 { 78 | font-weight: 500 !important; 79 | } 80 | } 81 | 82 | .td-sidebar { 83 | background-color: $spkb-bg !important; 84 | 85 | .td-search__input { 86 | background-color: white !important; 87 | } 88 | } 89 | 90 | // homepage 91 | #td-cover-block-0 { 92 | background-image: url('/spinkube-hero-bg.jpg') !important; 93 | 94 | h1.display-1 { 95 | font-size: 3.333rem; 96 | margin: 12vh auto !important; 97 | max-width: 66rem; 98 | } 99 | 100 | p.lead { 101 | font-size: 1.25rem; 102 | line-height: 2; 103 | margin: 1rem auto 4rem; 104 | max-width: 64rem; 105 | font-weight: 500; 106 | } 107 | } 108 | 109 | .td-home { 110 | .td-box--secondary { 111 | 112 | h3 { 113 | margin: 5rem auto 3rem !important; 114 | color: $spkb-purple; 115 | font-weight: 600; 116 | } 117 | 118 | p { 119 | max-width: 56rem; 120 | margin: 2rem auto 3rem; 121 | line-height: 2; 122 | color: $primary; 123 | text-align: left; 124 | } 125 | 126 | } 127 | } 128 | 129 | button.td-click-to-copy { 130 | 131 | &::before { 132 | color: rgba($secondary, 0.5); 133 | } 134 | } 135 | -------------------------------------------------------------------------------- /crd-reference/spin-operator.tmpl: -------------------------------------------------------------------------------- 1 | --- 2 | title: {{or .Metadata.Title "API Reference"}} 3 | weight: {{or .Metadata.Weight 1 }} 4 | {{- if .Metadata.Description}} 5 | description: {{.Metadata.Description}} 6 | {{- end}} 7 | categories: [Spin Operator] 8 | tags: [reference] 9 | --- 10 | {{- range .Groups }} 11 | {{- $group := . }} 12 | Resource Types: 13 | {{range .Kinds}} 14 | - [{{.Name}}](#{{ anchorize .Name }}) 15 | {{- end}}{{/* range .Kinds */}} 16 | 17 | {{- range .Kinds}} 18 | {{$kind := .}} 19 | ## {{.Name}} 20 | {{- range .Types}} 21 | {{- if not .IsTopLevel}} 22 | ### `{{.Name}}` 23 | {{if .ParentKey}}[back to parent](#{{.ParentKey}}){{end}} 24 | {{end}} 25 | 26 | {{.Description}} 27 | 28 |
| Name | 32 |Type | 33 |Description | 34 |Required | 35 |
|---|---|---|---|
| apiVersion | 41 |string | 42 |{{$group.Group}}/{{$group.Version}} | 43 |true | 44 |
| kind | 47 |string | 48 |{{$kind.Name}} | 49 |true | 50 |
| metadata | 53 |object | 54 |Refer to the Kubernetes API documentation for the fields of the `metadata` field. | 55 |true | 56 |
| {{if .TypeKey}}{{.Name}}{{else}}{{.Name}}{{end}} | 61 |{{.Type}} | 62 |
63 | {{.Description}} 64 | {{- if or .Schema.XValidations .Schema.Format .Schema.Enum .Schema.Default .Schema.Minimum .Schema.Maximum }} 65 | 66 | {{- end}} 67 | {{- if .Schema.XValidations }} 68 | Validations: 69 | {{- range .Schema.XValidations -}} 70 | 75 | {{- end }} 76 | {{- if .Schema.Enum }} 77 | Enum: {{ .Schema.Enum | toStrings | join ", " }} 78 | {{- end }} 79 | {{- if .Schema.Default }} 80 | Default: {{ .Schema.Default }} 81 | {{- end }} 82 | {{- if .Schema.Minimum }} 83 | Minimum: {{ .Schema.Minimum }} 84 | {{- end }} 85 | {{- if .Schema.Maximum }} 86 | Maximum: {{ .Schema.Maximum }} 87 | {{- end }} 88 | |
89 | {{.Required}} | 90 |
SpinKube is an open source, Kubernetes native project that streamlines developing, 9 | deploying, and operating WebAssembly (Wasm) workloads in Kubernetes - resulting in delivering smaller, more portable applications with exciting compute performance benefits.
10 | {{< blocks/link-down color="info" >}} 11 | {{< /blocks/cover >}} 12 | 13 | 14 | {{% blocks/lead color="secondary" %}} 15 | 16 | SpinKube combines the Spin operator, containerd shim Spin, and the runtime class manager (formerly KWasm) open source projects with contributions from Microsoft, SUSE, 20 | Liquid Reply, and Fermyon. By running applications at the Wasm abstraction layer, SpinKube gives 21 | developers a more powerful, efficient and scalable way to optimize application delivery on 22 | Kubernetes. 23 | 24 | 25 | ### Made with Contributions from: 26 | 27 | ||||| 28 | |---|---|---|---| 29 | 30 | ### Overview 31 | 32 | [**Spin Operator**](https://github.com/spinframework/spin-operator/) is a Kubernetes operator that enables 33 | deploying and running Spin applications in Kubernetes. It houses the SpinApp and SpinAppExecutor CRDs 34 | which are used for configuring the individual workloads and workload execution configuration such as 35 | runtime class. Spin Operator introduces a host of functionality such as resource-based scaling, 36 | event-driven scaling and much more. 37 | 38 | [**Containerd Shim Spin**](https://github.com/spinframework/containerd-shim-spin) provides a shim for running Spin 39 | workloads managed by containerd. The Spin workload uses this shim as a runtime class within Kubernetes enabling 40 | these workloads to function similarly to container workloads in Pods in Kubernetes. 41 | 42 | [**Runtime Class Manager**](https://github.com/spinframework/runtime-class-manager) is an operator that 43 | automates and manages the lifecycle of containerd shims in a Kubernetes environment. This includes tasks 44 | like installation, update, removal, and configuration of shims, reducing manual errors and improving 45 | reliability in managing WebAssembly (Wasm) workloads and other containerd extensions. 46 | 47 | [**Spin Kube Plugin**](https://github.com/spinframework/spin-plugin-kube) is a plugin for the [Spin](https://developer.fermyon.com/spin/v3/index) CLI 48 | that aims to ease the experience for scaffolding, deploying and inspecting Spin workloads in Kubernetes. 49 | 50 | ### Get Involved 51 | 52 | We have bi-weekly [community calls](https://docs.google.com/document/d/10is2YoNC0NpXw4_5lSyTfpPph9_A9wBissKGrpFaIrI/edit?usp=sharing) and a [Slack channel](https://cloud-native.slack.com/archives/C06PC7JA1EE). We would love to have you join us!53 | 54 | Check out the [contribution guidelines](/docs/contrib/) to learn how to get involved with the project. 55 | 56 | --- 57 | 58 | {{% /blocks/lead %}} 59 | 60 | {{% blocks/section %}} 61 | 62 |
66 |
67 | We are a Cloud Native Computing Foundation sandbox project.
68 |
69 | 70 |
The Linux Foundation® (TLF) has registered trademarks and uses trademarks. For a list of TLF trademarks, see Trademark Usage
71 |
72 |
73 | {{% /blocks/section %}}
74 |
--------------------------------------------------------------------------------
/content/en/cloud-native-computing.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/content/en/docs/install/rancher-desktop.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Installing on Rancher Desktop
3 | description: This tutorial shows how to integrate SpinKube and Rancher Desktop.
4 | date: 2024-02-16
5 | categories: [Spin Operator]
6 | tags: [Tutorials]
7 | weight: 7
8 | aliases:
9 | - /docs/spin-operator/tutorials/integrating-with-rancher-desktop
10 | ---
11 |
12 | [Rancher Desktop](https://rancherdesktop.io/) is an open-source application that provides all the
13 | essentials to work with containers and Kubernetes on your desktop.
14 |
15 | ### Prerequisites
16 |
17 | - An operating system compatible with Rancher Desktop (Windows, macOS, or Linux).
18 | - Administrative or superuser access on your computer.
19 |
20 | ### Step 1: Installing Rancher Desktop
21 |
22 | 1. **Download Rancher Desktop**:
23 | - Navigate to the [Rancher Desktop releases
24 | page](https://github.com/rancher-sandbox/rancher-desktop/releases). We tested this documentation with Rancher Desktop `1.19.1` with Spin `v3.2.0`, but it should work with more recent versions.
25 | - Select the appropriate installer for your operating system.
26 | 2. **Install Rancher Desktop**:
27 | - Run the downloaded installer and follow the on-screen instructions to complete the
28 | installation.
29 |
30 | ### Step 2: Configure Rancher Desktop
31 |
32 | - Open Rancher Desktop
33 | - Configure `containerd` as your container runtime engine (under **Preferences** -> **Container Engine**).
34 | - Make sure that the Enable Wasm option is checked in the **Preferences** → **Container Engine**
35 | section. Remember to always apply your changes.
36 |
37 | 
38 |
39 | - Navigate to the **Preferences** -> **Kubernetes** menu.
40 | - Enable Kubernetes, Traefik and Spin Operator (under **Preferences** -> **Kubernetes** ensure that the **Enable Kubernetes**, **Enable Traefik** and **Install Spin Operator** options are checked.)
41 |
42 | 
43 |
44 | - Make sure to select `rancher-desktop` from your Kubernetes contexts: `kubectl config use-context rancher-desktop`
45 |
46 | - Once your changes have been applied, go to the **Cluster Dashboard** -> **Workloads**. You should see the `spin-operator-controller-manager` deployed to the `spin-operator` namespace.
47 |
48 | ### Step 3: Creating a Spin Application
49 |
50 | 1. **Open a terminal** (Command Prompt, Terminal, or equivalent based on your OS).
51 | 2. **Create a new Spin application**: This command creates a new Spin application using the
52 | `http-js` template, named `hello-k3s`.
53 |
54 | ```bash
55 | $ spin new -t http-js hello-k3s --accept-defaults
56 | $ cd hello-k3s
57 | ```
58 |
59 | 3. We can edit the `/src/index.js` file and make the workload return a string "Hello from Rancher Desktop":
60 |
61 | ```javascript
62 | import { AutoRouter } from 'itty-router';
63 |
64 | let router = AutoRouter();
65 |
66 | router
67 | .get("/", () => new Response("Hello from Rancher Desktop")) // <-- this changed
68 | .get('/hello/:name', ({ name }) => `Hello, ${name}!`)
69 |
70 | addEventListener('fetch', (event) => {
71 | event.respondWith(router.fetch(event.request));
72 | });
73 | ```
74 |
75 | ### Step 4: Deploying Your Application
76 |
77 | 1. **Push the application to a registry**:
78 |
79 | ```bash
80 | $ npm install
81 | $ spin build
82 | $ spin registry push ttl.sh/hello-k3s:0.1.0
83 | ```
84 |
85 | Replace `ttl.sh/hello-k3s:0.1.0` with your registry URL and tag.
86 |
87 | 2. **Deploy your Spin application to the cluster**:
88 |
89 | Use the [`spin-kube` plugin](https://github.com/spinframework/spin-plugin-kube) to deploy your application to the cluster
90 |
91 | ```sh
92 | spin kube scaffold --from ttl.sh/hello-k3s:0.1.0 | kubectl apply -f -
93 | ```
94 |
95 | If we click on the Rancher Desktop’s “Cluster Dashboard”, we can see `hello-k3s` is running inside
96 | the “Workloads” dropdown section:
97 |
98 | 
99 |
100 | To access our app outside of the cluster, we can forward the port so that we access the application
101 | from our host machine:
102 |
103 | ```bash
104 | $ kubectl port-forward svc/hello-k3s 8083:80
105 | ```
106 |
107 | To test locally, we can make a request as follows:
108 |
109 | ```bash
110 | $ curl localhost:8083
111 | Hello from Rancher Desktop
112 | ```
113 |
114 | The above `curl` command or a quick visit to your browser at localhost:8083 will return the "Hello
115 | from Rancher Desktop" message:
116 |
117 | 
118 |
--------------------------------------------------------------------------------
/content/en/docs/install/quickstart.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Quickstart
3 | description: Learn how to setup a Kubernetes cluser, install SpinKube and run your first Spin App.
4 | weight: 2
5 | aliases:
6 | - /docs/quickstart
7 | - /docs/spin-operator/quickstart
8 | ---
9 |
10 | This Quickstart guide demonstrates how to set up a new Kubernetes cluster, install the SpinKube and
11 | deploy your first Spin application.
12 |
13 | ## Prerequisites
14 |
15 | For this Quickstart guide, you will need:
16 |
17 | - [kubectl](https://kubernetes.io/docs/tasks/tools/) - the Kubernetes CLI
18 | - [Rancher Desktop](https://rancherdesktop.io/) or [Docker
19 | Desktop](https://docs.docker.com/get-docker/) for managing containers and Kubernetes on your
20 | desktop
21 | - [k3d](https://k3d.io/v5.6.0/?h=installation#installation) - a lightweight Kubernetes distribution
22 | that runs on Docker
23 | - [Helm](https://helm.sh/docs/intro/install/) - the package manager for Kubernetes
24 |
25 | ### Set up Your Kubernetes Cluster
26 |
27 | 1. Create a Kubernetes cluster with a k3d image that includes the
28 | [containerd-shim-spin](https://github.com/spinframework/containerd-shim-spin) prerequisite already
29 | installed:
30 |
31 | ```console { data-plausible="copy-quick-create-k3d" }
32 | k3d cluster create wasm-cluster \
33 | --image ghcr.io/spinframework/containerd-shim-spin/k3d:v0.22.0 \
34 | --port "8081:80@loadbalancer" \
35 | --agents 2
36 | ```
37 |
38 | > Note: Spin Operator requires a few Kubernetes resources that are installed globally to the
39 | > cluster. We create these directly through `kubectl` as a best practice, since their lifetimes are
40 | > usually managed separately from a given Spin Operator installation.
41 |
42 | 2. Install cert-manager
43 |
44 | ```console { data-plausible="copy-quick-install-cert-manager" }
45 | kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.3/cert-manager.yaml
46 | kubectl wait --for=condition=available --timeout=300s deployment/cert-manager-webhook -n cert-manager
47 | ```
48 |
49 | 3. Apply the [Runtime
50 | Class](https://github.com/spinframework/spin-operator/blob/main/config/samples/spin-runtime-class.yaml)
51 | used for scheduling Spin apps onto nodes running the shim:
52 |
53 | > Note: In a production cluster you likely want to customize the Runtime Class with a `nodeSelector`
54 | > that matches nodes that have the shim installed. However, in the K3d example, they're installed on
55 | > every node.
56 |
57 | ```console { data-plausible="copy-quick-apply-runtime-class" }
58 | kubectl apply -f https://github.com/spinframework/spin-operator/releases/download/v0.6.1/spin-operator.runtime-class.yaml
59 | ```
60 |
61 | 4. Apply the [Custom Resource Definitions]({{< ref "glossary#custom-resource-definition-crd" >}})
62 | used by the Spin Operator:
63 |
64 | ```console { data-plausible="copy-quick-apply-crd" }
65 | kubectl apply -f https://github.com/spinframework/spin-operator/releases/download/v0.6.1/spin-operator.crds.yaml
66 | ```
67 |
68 | ## Deploy the Spin Operator
69 |
70 | Execute the following command to install the Spin Operator on the K3d cluster using Helm. This will
71 | create all of the Kubernetes resources required by Spin Operator under the Kubernetes namespace
72 | `spin-operator`. It may take a moment for the installation to complete as dependencies are installed
73 | and pods are spinning up.
74 |
75 | ```console { data-plausible="copy-quick-deploy-operator" }
76 | # Install Spin Operator with Helm
77 | helm install spin-operator \
78 | --namespace spin-operator \
79 | --create-namespace \
80 | --version 0.6.1 \
81 | --wait \
82 | oci://ghcr.io/spinframework/charts/spin-operator
83 | ```
84 |
85 | Lastly, create the [shim executor]({{< ref "glossary#spin-app-executor-crd" >}}):
86 |
87 | ```console { data-plausible="copy-quick-create-shim-executor" }
88 | kubectl apply -f https://github.com/spinframework/spin-operator/releases/download/v0.6.1/spin-operator.shim-executor.yaml
89 | ```
90 |
91 | ## Run the Sample Application
92 |
93 | You are now ready to deploy Spin applications onto the cluster!
94 |
95 | 1. Create your first application in the same `spin-operator` namespace that the operator is running:
96 |
97 | ```console { data-plausible="copy-quick-deploy-sample" }
98 | kubectl apply -f https://raw.githubusercontent.com/spinframework/spin-operator/main/config/samples/simple.yaml
99 | ```
100 |
101 | 2. Forward a local port to the application pod so that it can be reached:
102 |
103 | ```console { data-plausible="copy-quick-forward-local-port" }
104 | kubectl port-forward svc/simple-spinapp 8083:80
105 | ```
106 |
107 | 3. In a different terminal window, make a request to the application:
108 |
109 | ```console { data-plausible="copy-quick-make-request" }
110 | curl localhost:8083/hello
111 | ```
112 |
113 | You should see:
114 |
115 | ```bash
116 | Hello world from Spin!
117 | ```
118 |
119 | ## Next Steps
120 |
121 | Congrats on deploying your first SpinApp! Recommended next steps:
122 |
123 | - Scale your [Spin Apps with Horizontal Pod Autoscaler (HPA)]({{< ref "scaling-with-hpa" >}})
124 | - Scale your [Spin Apps with Kubernetes Event Driven Autoscaler (KEDA)]({{< ref "scaling-with-keda"
125 | >}})
126 |
--------------------------------------------------------------------------------
/content/en/docs/contrib/new-contributors.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Advice for new contributors
3 | description: Are you a contributor and not sure what to do? Want to help but just don't know how to get started? This is the section for you.
4 | weight: 1
5 | aliases:
6 | - /docs/contrib/feedback
7 | - /docs/spin-operator/support/feedback
8 | ---
9 |
10 | This page contains more general advice on ways you can contribute to SpinKube, and how to approach
11 | that.
12 |
13 | If you are looking for a reference on the details of making code contributions, see the [Writing
14 | code]({{< ref "writing-code" >}}) documentation.
15 |
16 | ## First steps
17 |
18 | Start with these steps to be successful as a contributor to SpinKube.
19 |
20 | ### Join the conversation
21 |
22 | It can be argued that collaboration and communication are the most crucial aspects of open source
23 | development. Gaining consensus on the direction of the project, and that your work is aligned with
24 | that direction, is key to getting your work accepted. This is why it is important to join the
25 | conversation early and often.
26 |
27 | To join the conversation, visit the `#spinkube` channel on the [CNCF
28 | Slack](https://cloud-native.slack.com/archives/C06PC7JA1EE).
29 |
30 | ### Read the documentation
31 |
32 | The SpinKube documentation is a great place to start. It contains information on how to get started
33 | with the project, how to contribute, and how to use the project. The documentation is also a great
34 | place to find information on the project's architecture and design.
35 |
36 | SpinKube's documentation is great but it is not perfect. If you find something that is unclear or
37 | incorrect, please submit a pull request to fix it. See the guide on [writing documentation]({{< ref
38 | "writing-documentation" >}}) for more information.
39 |
40 | ### Triage issues
41 |
42 | If an issue reports a bug, try and reproduce it. If you can reproduce it and it seems valid, make a
43 | note that you confirmed the bug. Make sure the issue is labeled properly. If you cannot reproduce
44 | the bug, ask the reporter for more information.
45 |
46 | ### Write tests
47 |
48 | Consider writing a test for the bug's behavior, even if you don't fix the bug itself.
49 |
50 | issues labeled `good first issue` are a great place to start. These issues are specifically tagged
51 | as being good for new contributors to work on.
52 |
53 | ## Guidelines
54 |
55 | As a newcomer on a large project, it's easy to experience frustration. Here's some advice to make
56 | your work on SpinKube more useful and rewarding.
57 |
58 | ### Pick a subject area that you care about, that you are familiar with, or that you want to learn about
59 |
60 | You don't already have to be an expert on the area you want to work on; you become an expert through
61 | your ongoing contributions to the code.
62 |
63 | ### Start small
64 |
65 | It's easier to get feedback on a little issue than on a big one, especially as a new contributor;
66 | the maintainters are more likely to have time to review a small change.
67 |
68 | ### If you're going to engage in a big task, make sure that your idea has support first
69 |
70 | This means getting someone else to confirm that a bug is real before you fix the issue, and ensuring
71 | that there's consensus on a proposed feature before you go implementing it.
72 |
73 | ### Be bold! Leave feedback!
74 |
75 | Sometimes it can be scary to put your opinion out to the world and say "this issue is correct" or
76 | "this patch needs work", but it's the only way the project moves forward. The contributions of the
77 | broad SpinKube community ultimately have a much greater impact than that of any one person. We can't
78 | do it without you!
79 |
80 | ### Err on the side of caution when marking things ready for review
81 |
82 | If you're really not certain if a pull request is ready for review, don't mark it as such. Leave a
83 | comment instead, letting others know your thoughts. If you're mostly certain, but not completely
84 | certain, you might also try asking on [Slack](https://cloud-native.slack.com/archives/C06PC7JA1EE)
85 | to see if someone else can confirm your suspicions.
86 |
87 | ### Wait for feedback, and respond to feedback that you receive
88 |
89 | Focus on one or two issues, see them through from start to finish, and repeat. The shotgun approach
90 | of taking on lots of issues and letting some fall by the wayside ends up doing more harm than good.
91 |
92 | ### Be rigorous
93 |
94 | When we say "this pull request must have documentation and tests", we mean it. If a patch doesn't
95 | have documentation and tests, there had better be a good reason. Arguments like "I couldn't find any
96 | existing tests of this feature" don't carry much weight; while it may be true, that means you have
97 | the extra-important job of writing the very first tests for that feature, not that you get a pass
98 | from writing tests altogether.
99 |
100 | ### Be patient
101 |
102 | It's not always easy for your issue or your patch to be reviewed quickly. This isn't personal. There
103 | are a lot of issues and pull requests to get through.
104 |
105 | Keeping your patch up to date is important. Review the pull request on GitHub to ensure that you've
106 | addressed all review comments.
107 |
--------------------------------------------------------------------------------
/content/en/docs/topics/selective-deployments.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Selective Deployments in Spin
3 | description: Learn how to deploy a subset of components from your SpinApp using Selective Deployments.
4 | date: 2024-11-10
5 | categories: [Spin Operator]
6 | tags: [Tutorials]
7 | weight: 10
8 | ---
9 |
10 | This article explains how to selectively deploy a subset of components from your Spin App using Selective Deployments. You will learn how to:
11 |
12 | - Scaffold a Specific Component from a Spin Application into a Custom Resource
13 | - Run a Selective Deployment
14 |
15 | Selective Deployments allow you to control which components within a Spin app are active for a specific instance of the app. With Component Selectors, Spin and SpinKube can declare at runtime which components should be activated, letting you deploy a single, versioned artifact while choosing which parts to enable at startup. This approach separates developer goals (building a well-architected app) from operational needs (optimizing for specific infrastructure).
16 |
17 | ## Prerequisites
18 |
19 | For this tutorial, you’ll need:
20 |
21 | - [kubectl](https://kubernetes.io/docs/tasks/tools/) - the Kubernetes CLI
22 | - Kubernetes cluster with the Spin Operator v0.4 and Containerd Spin Shim v0.17 - follow the [Quickstart](../install/quickstart.md) if needed
23 | - `spin kube` plugin v0.3 - follow [Installing the `spin kube` plugin](../install/spin-kube-plugin.md) if needed
24 |
25 | ## Scaffold a Specific Component from a Spin Application into a Custom Resource
26 |
27 | We’ll use a sample application called "Salutations", which demonstrates greetings via two components, each responding to a unique HTTP route. If we take a look at the [application manifest](https://github.com/spinframework/spin-operator/blob/main/apps/salutations/spin.toml), we’ll see that this Spin application is comprised of two components:
28 |
29 | - `Hello` component triggered by the `/hi` route
30 | - `Goodbye` component triggered by the `/bye` route
31 |
32 | ```yaml
33 | spin_manifest_version = 2
34 |
35 | [application]
36 | name = "salutations"
37 | version = "0.1.0"
38 | authors = ["Kate Goldenring | Name | 20 |Type | 21 |Description | 22 |Required | 23 |
|---|---|---|---|
| apiVersion | 27 |string | 28 |core.spinkube.dev/v1alpha1 | 29 |true | 30 |
| kind | 33 |string | 34 |SpinAppExecutor | 35 |true | 36 |
| metadata | 39 |object | 40 |Refer to the Kubernetes API documentation for the fields of the `metadata` field. | 41 |true | 42 |
| spec | 44 |object | 45 |
46 | SpinAppExecutorSpec defines the desired state of SpinAppExecutor 47 | |
48 | false | 49 |
| status | 51 |object | 52 |
53 | SpinAppExecutorStatus defines the observed state of SpinAppExecutor 54 | |
55 | false | 56 |
| Name | 70 |Type | 71 |Description | 72 |Required | 73 |
|---|---|---|---|
| createDeployment | 77 |boolean | 78 |
79 | CreateDeployment specifies whether the Executor wants the SpinKube operator
80 | to create a deployment for the application or if it will be realized externally. 81 | |
82 | true | 83 |
| deploymentConfig | 85 |object | 86 |
87 | DeploymentConfig specifies how the deployment should be configured when
88 | createDeployment is true. 89 | |
90 | false | 91 |
| Name | 106 |Type | 107 |Description | 108 |Required | 109 |
|---|---|---|---|
| caCertSecret | 113 |string | 114 |
115 | CACertSecret specifies the name of the secret containing the CA
116 | certificates to be mounted to the deployment. 117 | |
118 | false | 119 |
| installDefaultCACerts | 121 |boolean | 122 |
123 | InstallDefaultCACerts specifies whether the default CA
124 | certificate bundle should be generated. When set a new secret
125 | will be created containing the certificates. If no secret name is
126 | defined in `CACertSecret` the secret name will be `spin-ca`. 127 | |
128 | false | 129 |
| otel | 131 |object | 132 |
133 | Otel provides Kubernetes Bindings to Otel Variables. 134 | |
135 | false | 136 |
| runtimeClassName | 138 |string | 139 |
140 | RuntimeClassName is the runtime class name that should be used by pods created
141 | as part of a deployment. This should only be defined when SpintainerImage is not defined. 142 | |
143 | false | 144 |
| spinImage | 146 |string | 147 |
148 | SpinImage points to an image that will run Spin in a container to execute
149 | your SpinApp. This is an alternative to using the shim to execute your
150 | SpinApp. This should only be defined when RuntimeClassName is not
151 | defined. When specified, application images must be available without
152 | authentication. 153 | |
154 | false | 155 |
| Name | 169 |Type | 170 |Description | 171 |Required | 172 |
|---|---|---|---|
| exporter_otlp_endpoint | 176 |string | 177 |
178 | ExporterOtlpEndpoint configures the default combined otlp endpoint for sending telemetry 179 | |
180 | false | 181 |
| exporter_otlp_logs_endpoint | 183 |string | 184 |
185 | ExporterOtlpLogsEndpoint configures the logs-specific otlp endpoint 186 | |
187 | false | 188 |
| exporter_otlp_metrics_endpoint | 190 |string | 191 |
192 | ExporterOtlpMetricsEndpoint configures the metrics-specific otlp endpoint 193 | |
194 | false | 195 |
| exporter_otlp_traces_endpoint | 197 |string | 198 |
199 | ExporterOtlpTracesEndpoint configures the trace-specific otlp endpoint 200 | |
201 | false | 202 |