{"id":13867,"date":"2020-11-20T10:45:34","date_gmt":"2020-11-20T10:45:34","guid":{"rendered":"http:\/\/blog.stratio.com\/?p=13867"},"modified":"2023-09-20T15:29:32","modified_gmt":"2023-09-20T15:29:32","slug":"knative-serverless-without-vendor-lock-in","status":"publish","type":"post","link":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/","title":{"rendered":"Knative, serverless without vendor lock-in"},"content":{"rendered":"<h2><b>How serverless works:<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">Serverless means literally &#8220;without server&#8221; and it refers to a way to deploy and execute applications where the owner of the application doesn&#8217;t have to worry about the server and infrastructure used to serve it. The only responsibility of developers is to write the code needed for the application to work properly and the cloud provider is the one who has to dynamically provision&nbsp; the server, deploy the application in it, and make it work.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Because the code is totally independent of the platform and server on which it will be deployed, the developer doesn\u2019t need to define endpoints or listeners to communicate with the outside world, instead of this, the cloud provider is the one responsible for providing the means to communicate with other services using events that trigger the execution of the application logic.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Some of the biggest advantages of using serverless are:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">The code of the application is completely independent of the server in which it will be deployed.That means that there is nothing in the code related to the server nor infrastructure, in other words, the business code is completely decoupled from the server dependent code and this allows to deploy the same code in any platform without touching any line of code.<\/span><\/li>\n<\/ul>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">The owner of the service doesn&#8217;t have to worry about updates&nbsp; or the maintenance of the servers because they are part of the infrastructure managed by the cloud provider. This could represent a strong cost saving in the overall budget.<\/span><\/li>\n<\/ul>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Scalability of the application is managed automatically by the cloud provider and can be scaled down to 0 in the case of the application not having any traffic. This means that the cost of the application could be 0 when it is not in use allowing a pay per use billing model.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">However, one of its main features is also one of its biggest disadvantages, and this is because, as we have already said, the cloud provider is responsible for dynamically provisioning the infrastructure needed to deploy the application and its autoscaling, and because of this, it is very coupled to the cloud provider and could lead to the well-known problem called &#8220;vendor lock-in&#8221;.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">This lock-in is not present in the application code but it is present in the different components needed to communicate with the application such as message queues, datastores, gateways, etc.. because they have to be the ones available in the infrastructure of the cloud provider chosen.<\/span><\/p>\n<p><\/p>\n<h2><b>How Knative can help<\/b><\/h2>\n<p><a href=\"https:\/\/knative.dev\/\"><span style=\"font-weight: 400;\">Knative<\/span><\/a><span style=\"font-weight: 400;\"> arises as an alternative to avoid this vendor lock-in in the serverless world.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Knative was developed by Google in collaboration with many other companies such as Pivotal, IBM, Red Hat, and SAP and it was released as an open-source project under Apache 2.0 license in 2015.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The main goal of this project was precisely to offer a serverless platform built over <\/span><a href=\"https:\/\/kubernetes.io\/\"><span style=\"font-weight: 400;\">Kubernetes<\/span><\/a><span style=\"font-weight: 400;\">, to avoid the vendor lock-in and this way allow the development of a serverless platform that can be hosted in any of the main cloud providers without making any changes in the code.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The use of Kubernetes allows a company to deploy all the components needed for the application such as message queues or gateways inside the Kubernetes cluster and make it independent of the cloud provider infrastructure.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In addition to Kubernetes, Knative uses <\/span><a href=\"https:\/\/istio.io\/\"><span style=\"font-weight: 400;\">Istio<\/span><\/a><span style=\"font-weight: 400;\">, an open-source service mesh, in its serving module to provide routing functionalities which can be used to create blue-green deployments or canary releases.<\/span><\/p>\n<h3><b>Modules<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Knative offers two different modules to allow the user application to communicate with the outside world. Serving and Eventing. These modules can be used independently or can be used together depending on the capabilities required by the application.<\/span><\/p>\n<h4><b>Serving<\/b><\/h4>\n<p><span style=\"font-weight: 400;\">This module works by exposing endpoints through a Kubernetes service allowing the applications to be invoked through REST endpoints. To provide the routing capabilities needed to expose the service, Knative uses Istio as well as a set of CRDs (Custom Resource Definitions) explained in the following diagram:<\/span><\/p>\n<p><a href=\"https:\/\/knative.dev\/docs\/serving\/\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-13869 aligncenter\" src=\"http:\/\/blog.stratio.com\/wp-content\/uploads\/2020\/11\/object_model-1.jpg\" alt=\"\" width=\"540\" height=\"424\"><\/a><\/p>\n<p><i><span style=\"font-weight: 400;\">Image taken from: https:\/\/knative.dev\/docs\/serving\/<\/span><\/i><\/p>\n<p><\/p>\n<p><span style=\"font-weight: 400;\">CRDs Involved<\/span><\/p>\n<p><b>Service<\/b><span style=\"font-weight: 400;\">: It is the component that handles the lifecycle of the application. It is also the component responsible to define other CRDs ,like the routes, and to manage the different versions of the application, by default it points always to the latest revision deployed.<\/span><\/p>\n<p><b>Route<\/b><span style=\"font-weight: 400;\">: It is the component that handles the routing between the service endpoint and a concrete revision of the application. This is the component that uses Istio, and thanks to it, it can split traffic between different revisions to implement blue-green deployments or canary releases.<\/span><\/p>\n<p><b>Configuration<\/b><span style=\"font-weight: 400;\">: This component stores the configuration needed for the application, decoupling it from the code.<\/span><\/p>\n<p><b>Revision<\/b><span style=\"font-weight: 400;\">: This component is a pointer to a specific version of the tuple: code, configuration of the application, and it is immutable.<\/span><\/p>\n<p><\/p>\n<h4><b>Eventing<\/b><\/h4>\n<p><span style=\"font-weight: 400;\">This module uses a message broker to produce and consume events and this way allows a developer to deploy event driven applications. This module offers different ways of communications such as:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><b>Produce only<\/b><span style=\"font-weight: 400;\">: It sends events to the broker directly using a POST Rest endpoint.<\/span><\/li>\n<li><b>Consume only<\/b><span style=\"font-weight: 400;\">: It uses a trigger to filter out the events of a certain type stored in the message broker and send them to the application through a user-defined POST Rest endpoint. This process is shown in the diagram below.<\/span><\/li>\n<\/ul>\n<p><a href=\"https:\/\/knative.dev\/docs\/eventing\/\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-13871 aligncenter\" src=\"http:\/\/blog.stratio.com\/wp-content\/uploads\/2020\/11\/broker-trigger-overview-copia.jpg\" alt=\"\" width=\"870\" height=\"300\"><\/a><\/p>\n<p><\/p>\n<p><i><span style=\"font-weight: 400;\">Image taken from: https:\/\/knative.dev\/docs\/eventing\/<\/span><\/i><\/p>\n<ul>\n<li><b>Event transformation<\/b><span style=\"font-weight: 400;\">: It is used to define complex pipelines to transform events using channels and subscriptions.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">CRDs Involved<\/span><\/p>\n<p><b>Broker<\/b><span style=\"font-weight: 400;\">: This is the component responsible for receiving the events, store them, and send them to the services using the trigger. A broker has a specific type defined by the channel.<\/span><\/p>\n<p><b>Trigger<\/b><span style=\"font-weight: 400;\">: This is the component that listens to the broker and when an event is received, applies its filter and sends the event to the application subscribed to it. To do this it uses an endpoint defined by the application in the subscription object.<\/span><\/p>\n<p><b>Channel<\/b><span style=\"font-weight: 400;\">: It is the implementation of the broker. It can be Kafka, in memory, GCP pub\/sub, or others&#8230;<\/span><\/p>\n<p><b>Subscription<\/b><span style=\"font-weight: 400;\">: This is the component that defines, for every application subscribed to a particular channel, what is the endpoint that has to be invoked by the trigger when an event passes the filter defined in it.<\/span><\/p>\n<p><\/p>\n<h2><b>Getting started with Knative<\/b><\/h2>\n<h3><b>How does it work?<\/b><\/h3>\n<p><span style=\"font-weight: 400;\">Knative uses a custom Kubernetes operator to create the different CRDs as well as other Kubernetes API objects like deployments, pods, or services needed to run serverless workloads.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">This operator also creates virtual endpoints (endpoints not related to any pods) used to listen to requests that trigger the deployment creation when the first request reaches it. This way Knative can scale the applications to 0 when the application is not used.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The downside of this feature is that the response time of the first request is much higher because it has to wait for the deployment to be created and the pod to respond. The following requests will be much faster because the deployment is already created. Then, when a certain time threshold is reached without any new requests, the application scales down to 0 again, and the deployment is deleted.<\/span><\/p>\n<p><\/p>\n<h2><b>Conclusion<\/b><\/h2>\n<p><span style=\"font-weight: 400;\">As we have seen in this article, the serverless philosophy has many advantages compared to the traditional deploy and run model. One of them is to forget about maintenance,&nbsp; upgrades, and security patches of servers. Another important feature is the ability to scale down the applications to 0 when they are not used and this way save money paying only when they are used. This can save a lot of money especially in applications with irregular load over time.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The advantage of Knative over other serverless platforms is that it avoids the vendor lock-in by offering a platform developed over Kubernetes that can be deployed in any cloud that supports Kubernetes without changing anything.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Several companies have already taken advantage of Knative and currently offer commercial serverless platforms based on Knative ready to be used. Some of them are <\/span><a href=\"https:\/\/gardener.cloud\/documentation\/050-tutorials\/content\/howto\/knative-install\/\"><span style=\"font-weight: 400;\">Gardener<\/span><\/a><span style=\"font-weight: 400;\">, <\/span><a href=\"https:\/\/cloud.google.com\/run\/docs\/setup\"><span style=\"font-weight: 400;\">Google Cloud Run<\/span><\/a><span style=\"font-weight: 400;\">, <\/span><a href=\"https:\/\/cloud.ibm.com\/docs\/containers?topic=containers-serverless-apps-knative\"><span style=\"font-weight: 400;\">Managed Knative for IBM Cloud Kubernetes Service<\/span><\/a><span style=\"font-weight: 400;\">, <\/span><a href=\"https:\/\/docs.openshift.com\/container-platform\/4.5\/serverless\/serverless-getting-started.html\"><span style=\"font-weight: 400;\">Red Hat Openshift Serverless<\/span><\/a><span style=\"font-weight: 400;\">, <\/span><a href=\"https:\/\/docs.pivotal.io\/pfs\"><span style=\"font-weight: 400;\">Pivotal Function Service (PFS)<\/span><\/a><span style=\"font-weight: 400;\">, or <\/span><a href=\"https:\/\/cloud.triggermesh.io\/\"><span style=\"font-weight: 400;\">TriggerMesh Cloud <\/span><\/a><\/p>\n<p><\/p>\n\n\n<p><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Serverless means literally &#8220;without server&#8221; and it refers to a way to deploy and execute applications where the owner of the application doesn&#8217;t have to worry about the server and infrastructure used to serve it.<\/p>\n","protected":false},"author":2,"featured_media":13874,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[686],"tags":[16,19,534],"ppma_author":[794],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v22.9 (Yoast SEO v22.9) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Knative, serverless without vendor lock-in<\/title>\n<meta name=\"description\" content=\"Over the last few years and even now, we usually hear that in order to build a microservices architecture or any distributed system, the services must be stateless. However, these systems also need to store the state in some way. Discover how we can address this problem using stateful services that could manage distributed state at scale.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Knative, serverless without vendor lock-in\" \/>\n<meta property=\"og:description\" content=\"Over the last few years and even now, we usually hear that in order to build a microservices architecture or any distributed system, the services must be stateless. However, these systems also need to store the state in some way. Discover how we can address this problem using stateful services that could manage distributed state at scale.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\" \/>\n<meta property=\"og:site_name\" content=\"Stratio\" \/>\n<meta property=\"article:published_time\" content=\"2020-11-20T10:45:34+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-20T15:29:32+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1300\" \/>\n\t<meta property=\"og:image:height\" content=\"820\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@stratiobd\" \/>\n<meta name=\"twitter:site\" content=\"@stratiobd\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\"},\"author\":{\"name\":\"admin\",\"@id\":\"https:\/\/www.stratio.com\/blog\/#\/schema\/person\/af4f5fbbeb95bd7d55f79d9a677e615d\"},\"headline\":\"Knative, serverless without vendor lock-in\",\"datePublished\":\"2020-11-20T10:45:34+00:00\",\"dateModified\":\"2023-09-20T15:29:32+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\"},\"wordCount\":1356,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg\",\"keywords\":[\"Artifical Intelligence\",\"Big Data\",\"Cloud\"],\"articleSection\":[\"Product\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\",\"url\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\",\"name\":\"Knative, serverless without vendor lock-in\",\"isPartOf\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg\",\"datePublished\":\"2020-11-20T10:45:34+00:00\",\"dateModified\":\"2023-09-20T15:29:32+00:00\",\"description\":\"Over the last few years and even now, we usually hear that in order to build a microservices architecture or any distributed system, the services must be stateless. However, these systems also need to store the state in some way. Discover how we can address this problem using stateful services that could manage distributed state at scale.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage\",\"url\":\"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg\",\"contentUrl\":\"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg\",\"width\":1300,\"height\":820},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.stratio.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Knative, serverless without vendor lock-in\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.stratio.com\/blog\/#website\",\"url\":\"https:\/\/www.stratio.com\/blog\/\",\"name\":\"Stratio Blog\",\"description\":\"Corporate blog\",\"publisher\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.stratio.com\/blog\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.stratio.com\/blog\/#organization\",\"name\":\"Stratio\",\"url\":\"https:\/\/www.stratio.com\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.stratio.com\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/stratio.com\/blog\/wp-content\/uploads\/2020\/06\/stratio-web-logo-1.png\",\"contentUrl\":\"https:\/\/stratio.com\/blog\/wp-content\/uploads\/2020\/06\/stratio-web-logo-1.png\",\"width\":260,\"height\":55,\"caption\":\"Stratio\"},\"image\":{\"@id\":\"https:\/\/www.stratio.com\/blog\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/x.com\/stratiobd\",\"https:\/\/es.linkedin.com\/company\/stratiobd\",\"https:\/\/www.youtube.com\/c\/StratioBD\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.stratio.com\/blog\/#\/schema\/person\/af4f5fbbeb95bd7d55f79d9a677e615d\",\"name\":\"admin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.stratio.com\/blog\/#\/schema\/person\/image\/589aaf4b404b1fe099b09564062c4563\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/9b181ae4395243dccaf1c3e3a4749d81?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/9b181ae4395243dccaf1c3e3a4749d81?s=96&d=mm&r=g\",\"caption\":\"admin\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Knative, serverless without vendor lock-in","description":"Over the last few years and even now, we usually hear that in order to build a microservices architecture or any distributed system, the services must be stateless. However, these systems also need to store the state in some way. Discover how we can address this problem using stateful services that could manage distributed state at scale.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/","og_locale":"en_US","og_type":"article","og_title":"Knative, serverless without vendor lock-in","og_description":"Over the last few years and even now, we usually hear that in order to build a microservices architecture or any distributed system, the services must be stateless. However, these systems also need to store the state in some way. Discover how we can address this problem using stateful services that could manage distributed state at scale.","og_url":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/","og_site_name":"Stratio","article_published_time":"2020-11-20T10:45:34+00:00","article_modified_time":"2023-09-20T15:29:32+00:00","og_image":[{"width":1300,"height":820,"url":"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg","type":"image\/jpeg"}],"author":"admin","twitter_card":"summary_large_image","twitter_creator":"@stratiobd","twitter_site":"@stratiobd","twitter_misc":{"Written by":"admin","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#article","isPartOf":{"@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/"},"author":{"name":"admin","@id":"https:\/\/www.stratio.com\/blog\/#\/schema\/person\/af4f5fbbeb95bd7d55f79d9a677e615d"},"headline":"Knative, serverless without vendor lock-in","datePublished":"2020-11-20T10:45:34+00:00","dateModified":"2023-09-20T15:29:32+00:00","mainEntityOfPage":{"@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/"},"wordCount":1356,"commentCount":0,"publisher":{"@id":"https:\/\/www.stratio.com\/blog\/#organization"},"image":{"@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage"},"thumbnailUrl":"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg","keywords":["Artifical Intelligence","Big Data","Cloud"],"articleSection":["Product"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/","url":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/","name":"Knative, serverless without vendor lock-in","isPartOf":{"@id":"https:\/\/www.stratio.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage"},"image":{"@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage"},"thumbnailUrl":"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg","datePublished":"2020-11-20T10:45:34+00:00","dateModified":"2023-09-20T15:29:32+00:00","description":"Over the last few years and even now, we usually hear that in order to build a microservices architecture or any distributed system, the services must be stateless. However, these systems also need to store the state in some way. Discover how we can address this problem using stateful services that could manage distributed state at scale.","breadcrumb":{"@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#primaryimage","url":"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg","contentUrl":"https:\/\/www.stratio.com\/blog\/wp-content\/uploads\/2020\/11\/img_post_knative.jpg","width":1300,"height":820},{"@type":"BreadcrumbList","@id":"https:\/\/www.stratio.com\/blog\/knative-serverless-without-vendor-lock-in\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.stratio.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Knative, serverless without vendor lock-in"}]},{"@type":"WebSite","@id":"https:\/\/www.stratio.com\/blog\/#website","url":"https:\/\/www.stratio.com\/blog\/","name":"Stratio Blog","description":"Corporate blog","publisher":{"@id":"https:\/\/www.stratio.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.stratio.com\/blog\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.stratio.com\/blog\/#organization","name":"Stratio","url":"https:\/\/www.stratio.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.stratio.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/stratio.com\/blog\/wp-content\/uploads\/2020\/06\/stratio-web-logo-1.png","contentUrl":"https:\/\/stratio.com\/blog\/wp-content\/uploads\/2020\/06\/stratio-web-logo-1.png","width":260,"height":55,"caption":"Stratio"},"image":{"@id":"https:\/\/www.stratio.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/stratiobd","https:\/\/es.linkedin.com\/company\/stratiobd","https:\/\/www.youtube.com\/c\/StratioBD"]},{"@type":"Person","@id":"https:\/\/www.stratio.com\/blog\/#\/schema\/person\/af4f5fbbeb95bd7d55f79d9a677e615d","name":"admin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.stratio.com\/blog\/#\/schema\/person\/image\/589aaf4b404b1fe099b09564062c4563","url":"https:\/\/secure.gravatar.com\/avatar\/9b181ae4395243dccaf1c3e3a4749d81?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/9b181ae4395243dccaf1c3e3a4749d81?s=96&d=mm&r=g","caption":"admin"}}]}},"authors":[{"term_id":794,"user_id":2,"is_guest":0,"slug":"admin","display_name":"admin","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/9b181ae4395243dccaf1c3e3a4749d81?s=96&d=mm&r=g","author_category":"","first_name":"","last_name":"","user_url":"","job_title":"","description":""}],"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/posts\/13867"}],"collection":[{"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/comments?post=13867"}],"version-history":[{"count":19,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/posts\/13867\/revisions"}],"predecessor-version":[{"id":15655,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/posts\/13867\/revisions\/15655"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/media\/13874"}],"wp:attachment":[{"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/media?parent=13867"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/categories?post=13867"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/tags?post=13867"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.stratio.com\/blog\/wp-json\/wp\/v2\/ppma_author?post=13867"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}