Skip to content
BranchesTags

Repository files navigation

faas-netes

Go Report CardBuild StatusLicense: MITOpenFaaS

This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.

OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.

Watch a video demo from TechFieldDay Extra at Dockercon

OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.

Stack

In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)

  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors

Get started

Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.

How is this project different from others?

Reference guide

Configuration via Environmental variables

FaaS-netes can be configured via environment variables.

OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always

Readiness checking

The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.

Namespaces

By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.

Ingress

To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.

Image pull policy

By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update. If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube. In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store. faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.

Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.

About

Serverless Kubernetes with OpenFaaS (Functions as a Service)

github.com/openfaas/faas

Resources

Readme
MIT license

Contributing

Contributing
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - feri/faas-netes: Serverless Kubernetes with OpenFaaS (Functions as a Service) · GitHub
Skip to content
BranchesTags
Repository files navigation
faas-netes
Go Report CardBuild StatusLicense: MITOpenFaaS
This is a plugin to enable Kubernetes as an OpenFaaS backend. The existing CLI and UI are fully compatible. It also opens up the possibility for other plugins to be built for orchestration frameworks such as Nomad, Mesos/Marathon or even a cloud-managed back-end such as Hyper.sh or Azure ACI.
OpenFaaS also runs well on managed Kubernetes services like AKS and GKE. See our list of tutorials in the documentation site for more.
Watch a video demo from TechFieldDay Extra at Dockercon
OpenFaaS is an event-driven serverless framework for containers. Any container for Windows or Linux can be leveraged as a serverless function. OpenFaaS is quick and easy to deploy (less than 60 secs) and lets you avoid writing boiler-plate code.
Stack
In this README you'll find a technical overview and instructions for deploying FaaS on a Kubernetes cluster. (Docker Swarm is also supported in the main project)
  • Serverless framework for containers
  • Native Kubernetes integrations (API and ecosystem)
  • Built-in UI
  • YAML templates & helm chart
  • Over 11k GitHub stars
  • Independent open-source project with over 90 authors/contributors
Get started
Note: a CRD-based Kubernetes controller is also available for OpenFaaS in the incubator program - faas-o6s.
How is this project different from others?
Reference guide
Configuration via Environmental variables
FaaS-netes can be configured via environment variables.
OptionUsage
httpProbeBoolean - use http probe type for function readiness and liveness. Default: false
write_timeoutHTTP timeout for writing a response body from your function (in seconds). Default: 8
read_timeoutHTTP timeout for reading the payload from the client caller (in seconds). Default: 8
image_pull_policyImage pull policy for deployed functions (Always, IfNotPresent, Never. Default: Always
Readiness checking
The readiness checking for functions assumes you are using our function watchdog which writes a .lock file in the default "tempdir" within a container. To see this in action you can delete the .lock file in a running Pod with kubectl exec and the function will be re-scheduled.
Namespaces
By default all OpenFaaS functions and services are deployed to the openfaas and openfaas-fn namespaces. To alter the namespace use the helm chart.
Ingress
To configure ingress see the helm chart. By default NodePorts are used. These are listed in the deployment guide.
Image pull policy
By default, deployed functions will use an imagePullPolicy of Always, which ensures functions using static image tags are refreshed during an update.
If this is not desired behavior, set the image_pull_policy environment variable to an alternative. IfNotPresent is particularly useful when developing locally with minikube.
In this case, you can set your local environment to use minikube's docker so faas-cli build builds directly into minikube's image store.
faas-cli push is unnecessary in this workflow - use faas-cli build then faas-cli deploy.
Note: When set to Never, only local (or pulled) images will work. When set to IfNotPresent, function deployments may not be updated when using static image tags.
About
Serverless Kubernetes with OpenFaaS (Functions as a Service)
github.com/openfaas/faas
Resources
Readme
MIT license
Contributing
Contributing
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages