{"id":11365,"date":"2021-07-05T03:47:22","date_gmt":"2021-07-05T10:47:22","guid":{"rendered":"https:\/\/www.couchbase.com\/blog\/?p=11365"},"modified":"2025-06-13T22:39:23","modified_gmt":"2025-06-14T05:39:23","slug":"couchbase-autonomous-operator-proof-of-concept-guide","status":"publish","type":"post","link":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/","title":{"rendered":"How to Build a Couchbase Autonomous Operator Proof of Concept"},"content":{"rendered":"<p><strong>Whenever I hear about a customer&#8217;s first experience<\/strong> with the <a href=\"https:\/\/www.couchbase.com\/products\/cloud\/kubernetes?ref=blog\" rel=\"noopener\" target=\"_blank\">Couchbase Autonomous Operator (CAO)<\/a> for Kubernetes, their first question tends to be \u201cHow much?\u201d<\/p>\n<p>The answer is that it&#8217;s already included in their Enterprise Edition subscription. Joyous to hear  this, most customers move to the next stage of conducting a small Proof of Concept (PoC) using the Couchbase Autonomous Operator. <\/p>\n<p>If you\u2019re already using <a href=\"https:\/\/www.couchbase.com\/products\/capella\/\" rel=\"noopener\" target=\"_blank\">Couchbase<\/a>, you&#8217;re aware of the required maintenance practices, managing the service nodes, version upgrades, etc. There is also maintenance required outside of Couchbase, such as OS upgrades. All of these maintenance steps cost you personnel resources. <\/p>\n<p>The CAO alleviates this personnel resource pressure, enabling you to automate the management of common Couchbase tasks such as the configuration, creation, scaling, and recovery of Couchbase clusters. By reducing the complexity of running a Couchbase cluster, it lets you focus on the desired configuration and not worry about the details of manual deployment and life-cycle management.<\/p>\n<p>Often with the best intentions, customers jump into a PoC, and sometimes it\u2019s their first experience with Kubernetes (or K8s if you\u2019re cool). But the Couchbase Autonomous Operator is a complex tool: It orchestrates operations which would normally be performed by a team of skilled engineers constantly managing your Couchbase cluster around the clock. It helps to tread carefully.<\/p>\n<p>In this case, it&#8217;s important that you have a foundational understanding of Kubernetes and of the CAO. From there, you&#8217;ll build a successful Proof of Concept. Without this background knowledge, it will be difficult \u2013 or impossible \u2013 to troubleshoot your new PoC. <\/p>\n<p>This blog post takes you through how to quickly deploy a Couchbase Autonomous Operator and Couchbase cluster. <\/p>\n<h2>Before We Dive In<\/h2>\n<p>This blog post focuses on the CAO and assumes a certain level of Kubernetes knowledge. If you&#8217;re new, or if you&#8217;re rusty, <a href=\"https:\/\/kubernetes.io\/docs\/concepts\/overview\/what-is-kubernetes\/\" rel=\"noopener\" target=\"_blank\">here&#8217;s a quick refresher on Kubernetes<\/a>. <\/p>\n<p>Because of the vast and complex ecosystem that is Kubernetes, for the sake of this article, let&#8217;s make it as easy as possible to get a cluster running. The CAO is cloud agnostic and therefore runs in a multitude of cloud environments \u2013 whether that&#8217;s your own Kubernetes cluster, or a Kubernetes service from your public cloud provider. <\/p>\n<p>In this blog post, we\u2019re going to use <a href=\"https:\/\/kind.sigs.k8s.io\/docs\/user\/quick-start\/\" rel=\"noopener\" target=\"_blank\">Kubernetes in Docker, a.k.a. &#8220;kind&#8221;<\/a>, to run Kubernetes nodes as local containers, so you&#8217;ll need to have Docker installed and running. <\/p>\n<p>We\u2019re using kind for a multitude of reasons:<\/p>\n<ul>\n<ul>\n<li>The install is quick and easy<\/li>\n<li>There&#8217;s a default image to use for each Kubernetes version<\/li>\n<li>We can get an environment running as quickly as possible<\/li>\n<\/ul>\n<\/ul>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>It even kindly (<em>get it?<\/em>) tells you how to interact with the Kubernetes cluster and how to delete it when you\u2019re done. It&#8217;s all visualized from a single page and is great for a variety of use cases like continuous integration and delivery\/deployment (CI\/CD) and Infrastructure as Code (IaC). For beginners, it means you can easily provision and destroy clusters. <\/p>\n<h2>How to Install kind<\/h2>\n<p>First, make sure you have Docker installed. Then, to install kind, follow these steps for your OS:<\/p>\n<p>On Linux: <\/p>\n<pre class=\"lang:sh decode:true\" title=\"Installing kind in Linux\">\r\ncurl -Lo .\/kind https:\/\/kind.sigs.k8s.io\/dl\/v0.11.0\/kind-linux-amd64\r\nchmod +x .\/kind\r\nmv .\/kind \/some-dir-in-your-PATH\/kind\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>On macOS via Homebrew:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Installing kind on Mac\">\r\nbrew install kind\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>On Windows:<\/p>\n<pre class=\"lang:sh decode:true \" title=\"Installing kind on Windows\">\r\ncurl.exe -Lo kind-windows-amd64.exe https:\/\/kind.sigs.k8s.io\/dl\/v0.11.0\/kind-windows-amd64\r\nMove-Item .kind-windows-amd64.exe c:some-dir-in-your-PATHkind.exe\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<h3>Creating a Cluster<\/h3>\n<p>Before you start to create a cluster, remember that kind utilises Docker for its Kubernetes nodes, so ensure that Docker is running before you start.<\/p>\n<p>Creating a cluster in kind is simple, you could just run <code>kind create cluster<\/code> and have a default cluster startup. Kind is very customisable, but in this article we will mostly use the defaults, only modifying the worker node configuration.<\/p>\n<h4>What Is YAML?<\/h4>\n<p><a href=\"https:\/\/yaml.org\/\" rel=\"noopener\" target=\"_blank\">YAML<\/a> is a markup language which is commonly used in configuration files across the Kubernetes ecosystem. <\/p>\n<p>If you haven\u2019t encountered YAML before, it has an intentionally minimal syntax and its basic structure is a map. YAML is reliant on its indentation to indicate nesting. As in Python, the format of this indentation is very important, so <em>make sure your editor uses spaces as opposed to tabs<\/em>.<\/p>\n<h4>Your First YAML Configuration File: Your kind Cluster<\/h4>\n<p>Create the following configuration file, named <code>kind-config.yaml<\/code>, which we\u2019ll use when creating our kind cluster:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"kind Cluster Configuration File\">\r\nkind: Cluster\r\napiVersion: kind.x-k8s.io\/v1alpha4\r\n# One control plane node and three \"workers\".\r\n#\r\n# While these will not add more real compute capacity and\r\n# have limited isolation, this can be useful for testing\r\n# rolling updates etc.\r\n#\r\n# The API-server and other control plane components will be\r\n# on the control-plane node.\r\n#\r\n# You probably don't need this unless you are testing Kubernetes itself.\r\nnodes:\r\n- role: control-plane\r\n- role: worker\r\n- role: worker\r\n- role: worker\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>Create your cluster with the following command:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"kind Command to Create Cluster\">\r\nkind create cluster --name=couchbase --config=kind-config.yaml\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>After your cluster is created, run the following command: <code>kubectl cluster-info --context kind-couchbase<\/code>. You should get output similar to the following to let you know you have a running Kubernetes cluster:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Kubernetes Cluster Info Status\">\r\n% kubectl cluster-info --context kind-couchbase\r\nKubernetes control plane is running at https:\/\/127.0.0.1:57957\r\nKubeDNS is running at https:\/\/127.0.0.1:57957\/api\/v1\/namespaces\/kube-system\/services\/kube-dns:dns\/proxy\r\n\r\nTo further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>&#8220;What is <code>kubectl<\/code>?&#8221; I hear you cry. It\u2019s the command which is used to interact with Kubernetes clusters. It\u2019s not something specific to Couchbase or kind. You interact with different clusters by changing the &#8220;context&#8221;. <a href=\"https:\/\/kubernetes.io\/docs\/reference\/kubectl\/overview\/\" rel=\"noopener\" target=\"_blank\">Read more about kubectl from Kubernetes themselves<\/a>.<\/p>\n<p>Diving deeper into this brave new world, we\u2019ll propose a question: If our cluster is called <code>couchbase<\/code> in kind, then why are we using <code>kind-couchbase<\/code> with kubectl? That&#8217;s because <code>kind-couchbase<\/code> is the name of the context we use to interact with the cluster.<\/p>\n<p>Running the following command will show you all contexts you have configured:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Kubernetes Get Config Contexts\">\r\n% kubectl config get-contexts\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>You should have a <code>*<\/code> in the current column next to the <code>kind-couchbase<\/code> entry.<\/p>\n<h2>Installing the Couchbase Autonomous Operator on Your Kubernetes Cluster<\/h2>\n<p>Now that you have a running Kubernetes cluster, <a href=\"https:\/\/docs.couchbase.com\/operator\/current\/install-kubernetes.html?ref=blog\" rel=\"noopener\" target=\"_blank\">it\u2019s time to install the CAO<\/a>.<\/p>\n<h3>Installation Prerequisites<\/h3>\n<p>Run through the prerequisites to download the CAO, navigate to the directory of the Download in your terminal, unzip it, and move into the folder.<\/p>\n<h3>Install the Custom Resource Definitions<\/h3>\n<p>The next step in the docs is to install the Couchbase Custom Resource Definitions (CRDs). Let&#8217;s take a closer look at what these are.<\/p>\n<p>Go ahead and take a look at the crd file <code>crd.yaml<\/code> in your unzipped folder. You\u2019ll see thousands of lines of defined Couchbase resources. The reason you need to install these is to extend the Kubernetes API and define specific Couchbase resources in order for it to manage them across your Kubernetes applications. <\/p>\n<p>For example, you would use these resources to validate a CAO deployment config. <a href=\"https:\/\/kubernetes.io\/docs\/concepts\/extend-kubernetes\/api-extension\/custom-resources\/\" rel=\"noopener\" target=\"_blank\">Here\u2019s the docs from Kubernetes on Custom Resources<\/a>.<\/p>\n<p>To install the CRDs which come with the operator, use the following command:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Create your CAO deployment\">\r\n$ kubectl create -f crd.yaml\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<h3>Install the Operator<\/h3>\n<p>The operator consists of two components. I want to give you a bit more of an overview here so that you know exactly what you\u2019re installing and why.<\/p>\n<h4>The Dynamic Admission Controller (DAC)<\/h4>\n<p>Because we\u2019re using custom resources, Kubernetes has no idea which values are acceptable, as opposed to native resource types. <\/p>\n<p>The Dynamic Admission Controller (DAC) is a gatekeeper which checks the validity of resources and applies necessary defaults before being committed to <code>etcd<\/code> (<a href=\"https:\/\/kubernetes.io\/docs\/concepts\/overview\/components\/#etcd\" rel=\"noopener\" target=\"_blank\">a key-value store for your cluster data<\/a>.)<\/p>\n<p>The Couchbase Docs team has done a fantastic job of explaining <a href=\"https:\/\/docs.couchbase.com\/operator\/current\/concept-operator.html#dynamic-admission-controller-architecture\" rel=\"noopener\" target=\"_blank\">the many benefits to using the Dynamic Admission Controller here<\/a>.<\/p>\n<p>Here is an excerpt from the Couchbase Documentation with a graphic on how the DAC interrogates requests:<\/p>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-11370\" src=\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2021\/06\/admission.png\" alt=\"Couchbase  Dynamic Admission Controller architecture diagram\" width=\"521\" height=\"201\" srcset=\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/06\/admission.png 521w, https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/06\/admission-300x116.png 300w\" sizes=\"auto, (max-width: 521px) 100vw, 521px\" \/><\/p>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<ol>\n<li>A client connects to the Kubernetes API and sends a request to create a resource. The resource specification is encoded as JSON.<\/li>\n<li>The API forwards the JSON to the mutating endpoint of the Dynamic Admission Controller. A mutating webhook is responsible for altering the resource (applying default values, for example). It may optionally choose to accept or reject the create request.<\/li>\n<li>The API forwards the JSON to the validating endpoint of the Dynamic Admission Controller. A validating webhook is responsible for validating specification constraints above and beyond those offered by JSON schema validation provided by the custom resource definition. It may optionally choose to accept or reject the create request.<\/li>\n<li>Once all admission checks have passed, the resource is persisted in the database (<code>etcd<\/code>).<\/li>\n<li>The API responds to the client that the create request has been accepted.<\/li>\n<\/ol>\n<p>If either of the admission checks in stages 2 and 3 respond that the resource is not acceptable, the API will go directly to stage 5 and return any errors returned by the DAC.<\/p>\n<p>Install the Dynamic Admission Controller with the following command:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Command to install the Dynamic Admission Controller\">\r\n$ bin\/cbopcfg create admission\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<h4>The Operator<\/h4>\n<p>I&#8217;ll quote the Couchbase Documentation again, since I can&#8217;t express it better myself:<\/p>\n<p><em>During the lifetime of the Couchbase cluster the Operator continually compares the state of Kubernetes resources with what is requested in the <code>CouchbaseCluster<\/code> resource, reconciling as necessary to make reality match what was requested.<\/em><\/p>\n<p>Let\u2019s pick at this further. The Operator lets you declare the cluster state you want, and it will take care of the rest. When the state of the cluster needs to change, e.g., adding Couchbase nodes, expanding available services etc., you can simply declare this and the Operator achieves this new state.<\/p>\n<p>These are complex operations which require precision and expertise to manage all of the moving parts. You <em>could<\/em> perform all of these tasks manually, but the Operator automates all of this and performs all of the operations with Couchbase\u2019s best practices in mind.<\/p>\n<p>To wrap up this section, you now know a little bit more about what makes up a CAO deployment \u2013 rather than just blindly installing the components. This is knowledge you&#8217;ll need when you&#8217;re running a multi-cloud Couchbase cluster using the CAO in a few months time.<\/p>\n<p>Now that you know what you&#8217;re installing, use the following command to install the operator:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Command to install the Couchbase Autonomous Operator\">\r\n$ bin\/cbopcfg create operator\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<h3>Verifying the DAC<\/h3>\n<p>You can check the status of the Couchbase Autonomous Operator by getting the deployments, and you can also specifically check the status of your <code>CouchbaseCluster<\/code> deployment by running:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Command to get Kubernetes Deployments\">\r\n$ kubectl get deployments\r\nNAME                           READY   UP-TO-DATE   AVAILABLE   AGE\r\ncouchbase-operator             1\/1     1            1           53s\r\ncouchbase-operator-admission   1\/1     1            1           93s\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>You should see output similar to the above. Now you can move on to actually deploying a Couchbase cluster(!).<\/p>\n<h3>Alternative Deployment Methods<\/h3>\n<p><a href=\"https:\/\/helm.sh\/\" rel=\"noopener\" target=\"_blank\">Helm<\/a> is a package manager for Kubernetes, somewhat similar to brew\/apt, etc. <\/p>\n<p>According to Matt Faina, one of Helm&#8217;s co-founders, a package manager is:<\/p>\n<p><em>\u201cTooling that enables someone who has knowledge of an application and a platform to package up an application so that someone else who has neither extensive knowledge of the platform or the way it needs to be run on the platform can use it.\u201d<\/em><\/p>\n<p>Packages in Helm are referred to as <em>charts<\/em>. They are deployable units for Kubernetes-bound applications.<\/p>\n<p>You can <a href=\"https:\/\/docs.couchbase.com\/operator\/current\/helm-setup-guide.html?ref=blog\" rel=\"noopener\" target=\"_blank\">use Helm to easily set up the Couchbase Autonomous Operator and deploy Couchbase clusters following this documentation<\/a>. By default, the official Couchbase Helm chart deploys the Couchbase Autonomous Operator, the Dynamic Admission Controller, and a fully configured Couchbase cluster.<\/p>\n<h2>Deploying Your Couchbase Cluster on the CAO<\/h2>\n<p>I&#8217;ll be using the documentation on <a href=\"https:\/\/docs.couchbase.com\/operator\/current\/howto-couchbase-create.html?ref=blog\" rel=\"noopener\" target=\"_blank\">how to create a Couchbase Deployment<\/a> as the source of truth for this section, but I&#8217;ll break it down step by step.<\/p>\n<p>Couchbase clusters are defined against the Operator \u2013 as we discussed above \u2013 and this definition is used to check the current status of the <code>CouchbaseCluster<\/code> resource. <\/p>\n<p>This YAML definition is derived from the docs, but I\u2019ve made a few changes so that things are a bit easier on your kind nodes. (Too many containers on a laptop leads to Badness\u2122.) Note the changes include only deploying the data service, but still keeping the node count at three in order to provide high availability and performance, and changing the name to <code>data_service<\/code> to avoid code rot. <\/p>\n<p>Create a file called <code>data_cluster.yaml<\/code> and copy this text into it:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"YAML definition for our Couchbase cluster\">\r\napiVersion: v1\r\nkind: Secret\r\nmetadata:\r\n  name: cb-example-auth\r\ntype: Opaque\r\ndata:\r\n  username: QWRtaW5pc3RyYXRvcg==  # Administrator\r\n  password: cGFzc3dvcmQ=          # password\r\n---\r\napiVersion: couchbase.com\/v2\r\nkind: CouchbaseBucket\r\nmetadata:\r\n  name: default  \r\nspec:\r\n  memoryQuota: 128Mi\r\n---\r\napiVersion: couchbase.com\/v2\r\nkind: CouchbaseCluster\r\nmetadata:\r\n  name: cb-example  \r\nspec:\r\n  image: couchbase\/server:6.6.2  \r\n  security:\r\n    adminSecret: cb-example-auth\r\n  networking:\r\n    exposeAdminConsole: true\r\n    adminConsoleServices:\r\n    - data\r\n  buckets:\r\n    managed: true\r\n  servers:\r\n  - size: 3  \r\n    name: data_service\r\n    services:\r\n    - data\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>Deploy the configuration using the following command:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"kubectl command to create the Couchbase cluster based on the YAML configuration file\">\r\n$ kubectl create -f data_cluster.yaml\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>You can watch as the Operator creates pods and provisions your cluster as per your specification by running the following soon after creating your deployment (above). This will show you the operator creating pods:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Kubernetes - kubectl command to get pods\">\r\n$ kubectl get pods\r\nNAME                                            READY   STATUS              RESTARTS   AGE\r\ncb-example-0000                                 0\/1     ContainerCreating   0          32s\r\ncouchbase-operator-7df6c5fc4c-xjmlb             1\/1     Running             0          9m26s\r\ncouchbase-operator-admission-7776986946-p94xr   1\/1     Running             0          10m\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>Note that the pod <code>cb-example-0000<\/code> isn\u2019t marked as ready (<code>0\/1<\/code>) and has the status <code>ContainerCreating<\/code>. Once deployment has been carried out, make sure you verify it.<\/p>\n<p>Keep running <code>kubectl get pods<\/code> until you see three <code>cb-example-****<\/code> pods with their status as <code>Running<\/code> and <code>1\/1<\/code> under the <code>Ready<\/code> column. <strong>Do not progress until this state is satisfied.<\/strong> This is the state you&#8217;ve defined in your <code>data_cluster.yaml<\/code>.<\/p>\n<p>Use the following command to further verify that your data service is available on your Cluster: <\/p>\n<pre class=\"lang:sh decode:true\" title=\"Kubernetes - kubectl command to get pods running the data service\">\r\n$ kubectl get pods -l couchbase_cluster=cb-example,couchbase_service_data=enabled\r\nNAME              READY   STATUS    RESTARTS   AGE\r\ncb-example-0000   1\/1     Running   0          73m\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>Note you should receive similar output to this example above, but depending on your cluster deployment, results will differ.<\/p>\n<h2>Port Forwarding and Accessing the Couchbase GUI<\/h2>\n<p>In order to access other Couchbase services for your PoC, you&#8217;ll need access to the Couchbase GUI. <\/p>\n<p><a href=\"https:\/\/docs.couchbase.com\/operator\/current\/howto-ui.html?ref=blog\" rel=\"noopener\" target=\"_blank\">This guide runs through how to set up port forwarding<\/a>. Port forwarding is helpful as you\u2019ll need to access the Couchbase GUI in your Proof of Concept. It might also come in handy when you need to use <code>cbc-pillowfight<\/code> for load testing or <code>cbimport<\/code> for getting some sample docs into the cluster.<\/p>\n<p>Using the output from the previous command provides you with a pod which is running the data service. This pod name can then be used to forward the port for the Couchbase GUI. <\/p>\n<p>Run the following command:<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Kubernetes - kubectl command to forward port 8091 from a specific pod\">\r\n$ kubectl port-forward cb-example-0000 8091\r\nForwarding from 127.0.0.1:8091 -&gt; 8091\r\nForwarding from [::1]:8091 -&gt; 8091\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>This command should provide you with output similar to what&#8217;s listed above. After running the command, you can access the Couchbase GUI through <a href=\"http:localhost:8091\" rel=\"noopener\" target=\"_blank\">http:localhost:8091<\/a>.<\/p>\n<h2>Modifying Your Couchbase Deployment<\/h2>\n<p>One thing you&#8217;ll definitely want to include in your PoC is the ability to <a href=\"https:\/\/docs.couchbase.com\/operator\/current\/howto-couchbase-update.html?ref=blog\" rel=\"noopener\" target=\"_blank\">modify your Couchbase cluster through the YAML file<\/a>. This gives you the flexibility to shape and scale your cluster. <\/p>\n<p>Make note that you aren\u2019t using <code>kubectl create<\/code> anymore. Replace the previous definition with a new one using <code>kubectl apply<\/code> or <code>kubectl replace<\/code>.<\/p>\n<p>One test to run through would be to add another Couchbase service to your current cluster. Since I\u2019m just using my laptop, I&#8217;m only going to add an additional service: eventing.<\/p>\n<pre class=\"lang:sh decode:true\" title=\"Couchbase Cluster YAML Config - new eventing service addition to cluster\">\r\napiVersion: v1\r\nkind: Secret\r\nmetadata:\r\n  name: cb-example-auth\r\ntype: Opaque\r\ndata:\r\n  username: QWRtaW5pc3RyYXRvcg==  # Administrator\r\n  password: cGFzc3dvcmQ=          # password\r\n---\r\napiVersion: couchbase.com\/v2\r\nkind: CouchbaseBucket\r\nmetadata:\r\n  name: default  \r\nspec:\r\n  memoryQuota: 128Mi\r\n---\r\napiVersion: couchbase.com\/v2\r\nkind: CouchbaseCluster\r\nmetadata:\r\n  name: cb-example  \r\nspec:\r\n  image: couchbase\/server:6.6.2  \r\n  security:\r\n    adminSecret: cb-example-auth\r\n  networking:\r\n    exposeAdminConsole: true\r\n    adminConsoleServices:\r\n    - data\r\n  buckets:\r\n    managed: true\r\n  servers:\r\n  - size: 3  \r\n    name: data_eventing_service\r\n    services:\r\n    - data\r\n    - eventing\r\n<\/pre>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>Once you\u2019ve made the change you can deploy your config to the operator: <code>kubectl apply -f &lt;path to updated config&gt;<\/code>. Verify that the new service has been added using the verbose <code>get pods<\/code> listing. Finally follow the steps to forward the port for the GUI again and check that the new service is included in the cluster.<\/p>\n<p>At this point it\u2019s important to note that the incremental addition of features to an operator <code>config<\/code> is somewhat of a best practice. With iterative addition of features and configurations to your deployment, you can test the cluster at each stage, confirming that your configuration is valid.<\/p>\n<h2>Conclusion<\/h2>\n<p>To conclude, in this article you&#8217;ve learned more about the makeup of the Couchbase Autonomous Operator and how you can orchestrate it to provision a Couchbase cluster, particularly for a Proof of Concept (PoC) project.<\/p>\n<p>The CAO consistently checks the state of your Couchbase cluster ensuring that it meets your defined specification. Furthermore, you can deploy the CAO specification across any Kubernetes environment. This gives you a fantastic level of freedom and removes public cloud vendor lock-in. You can rely on the Operator to maintain cluster health as per your spec, and when you need to perform functions like cluster upgrades, you can easily do so through your YAML file.<\/p>\n<p>In the future, I&#8217;ll publish more blog posts that explain how to deploy even more use cases of the Couchbase Autonomous Operator. If you can&#8217;t wait till then, <a href=\"https:\/\/docs.couchbase.com\/operator\/current\/overview.html?ref=blog\" rel=\"noopener\" target=\"_blank\">dig into the CAO documentation to start exploring<\/a>. I can&#8217;t wait to hear what you build.<\/p>\n<div class=\"wp-block-spacer\" style=\"height: 15px\" aria-hidden=\"true\"> <\/div>\n<p>&nbsp;<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Whenever I hear about a customer&#8217;s first experience with the Couchbase Autonomous Operator (CAO) for Kubernetes, their first question tends to be \u201cHow much?\u201d The answer is that it&#8217;s already included in their Enterprise Edition subscription. Joyous to hear this, [&hellip;]<\/p>\n","protected":false},"author":76077,"featured_media":11492,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1815,9284,6319,2273,2322],"tags":[1519,2365,1261,9247,1545,2128],"ppma_author":[9168],"class_list":["post-11365","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-best-practices-and-tutorials","category-couchbase-autonomous-operator","category-customers","category-eventing","category-kubernetes","tag-docker","tag-helm","tag-json","tag-key-value-store","tag-kubernetes","tag-proof-of-concept"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v25.7.1 (Yoast SEO v25.7) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>How to Build a Couchbase Autonomous Operator Proof of Concept<\/title>\n<meta name=\"description\" content=\"Discover how to quickly build a Proof of Concept (PoC) environment for the Couchbase Autonomous Operator for Kubernetes in this walkthrough developer guide.\" \/>\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.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Build a Couchbase Autonomous Operator Proof of Concept\" \/>\n<meta property=\"og:description\" content=\"Discover how to quickly build a Proof of Concept (PoC) environment for the Couchbase Autonomous Operator for Kubernetes in this walkthrough developer guide.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\" \/>\n<meta property=\"og:site_name\" content=\"The Couchbase Blog\" \/>\n<meta property=\"article:published_time\" content=\"2021-07-05T10:47:22+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-06-14T05:39:23+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Sam Redman, Solutions Engineer\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sam Redman, Solutions Engineer\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\"},\"author\":{\"name\":\"Sam Redman\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/512e4ed8ed1188a93cb7c3aee277f408\"},\"headline\":\"How to Build a Couchbase Autonomous Operator Proof of Concept\",\"datePublished\":\"2021-07-05T10:47:22+00:00\",\"dateModified\":\"2025-06-14T05:39:23+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\"},\"wordCount\":2465,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg\",\"keywords\":[\"docker\",\"helm\",\"JSON\",\"key-value store\",\"kubernetes\",\"proof of concept\"],\"articleSection\":[\"Best Practices and Tutorials\",\"Couchbase Autonomous Operator\",\"Customers\",\"Eventing\",\"Kubernetes\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\",\"url\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\",\"name\":\"How to Build a Couchbase Autonomous Operator Proof of Concept\",\"isPartOf\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg\",\"datePublished\":\"2021-07-05T10:47:22+00:00\",\"dateModified\":\"2025-06-14T05:39:23+00:00\",\"description\":\"Discover how to quickly build a Proof of Concept (PoC) environment for the Couchbase Autonomous Operator for Kubernetes in this walkthrough developer guide.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage\",\"url\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg\",\"contentUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg\",\"width\":1200,\"height\":628,\"caption\":\"Learn how to easily build a PoC Kubernetes environment to test out the Couchbase Autonomous Operator\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.couchbase.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"How to Build a Couchbase Autonomous Operator Proof of Concept\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#website\",\"url\":\"https:\/\/www.couchbase.com\/blog\/\",\"name\":\"The Couchbase Blog\",\"description\":\"Couchbase, the NoSQL Database\",\"publisher\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.couchbase.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\",\"name\":\"The Couchbase Blog\",\"url\":\"https:\/\/www.couchbase.com\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png\",\"contentUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png\",\"width\":218,\"height\":34,\"caption\":\"The Couchbase Blog\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/512e4ed8ed1188a93cb7c3aee277f408\",\"name\":\"Sam Redman\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/image\/69dc9b1e46ceb237d29e1e4b626c6bcc\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/ee34f7b9f2c46328736cdab03babdfd5ddc97cdd4a12ddd4b1b2d0f455eba51d?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/ee34f7b9f2c46328736cdab03babdfd5ddc97cdd4a12ddd4b1b2d0f455eba51d?s=96&d=mm&r=g\",\"caption\":\"Sam Redman\"},\"description\":\"Solutions Engineer at Couchbase. Sam has previously as a developer and an SRE before joining Couchbase.\",\"url\":\"https:\/\/www.couchbase.com\/blog\/author\/sam-redman\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"How to Build a Couchbase Autonomous Operator Proof of Concept","description":"Discover how to quickly build a Proof of Concept (PoC) environment for the Couchbase Autonomous Operator for Kubernetes in this walkthrough developer guide.","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.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/","og_locale":"en_US","og_type":"article","og_title":"How to Build a Couchbase Autonomous Operator Proof of Concept","og_description":"Discover how to quickly build a Proof of Concept (PoC) environment for the Couchbase Autonomous Operator for Kubernetes in this walkthrough developer guide.","og_url":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/","og_site_name":"The Couchbase Blog","article_published_time":"2021-07-05T10:47:22+00:00","article_modified_time":"2025-06-14T05:39:23+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg","type":"image\/jpeg"}],"author":"Sam Redman, Solutions Engineer","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Sam Redman, Solutions Engineer","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#article","isPartOf":{"@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/"},"author":{"name":"Sam Redman","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/512e4ed8ed1188a93cb7c3aee277f408"},"headline":"How to Build a Couchbase Autonomous Operator Proof of Concept","datePublished":"2021-07-05T10:47:22+00:00","dateModified":"2025-06-14T05:39:23+00:00","mainEntityOfPage":{"@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/"},"wordCount":2465,"commentCount":0,"publisher":{"@id":"https:\/\/www.couchbase.com\/blog\/#organization"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage"},"thumbnailUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg","keywords":["docker","helm","JSON","key-value store","kubernetes","proof of concept"],"articleSection":["Best Practices and Tutorials","Couchbase Autonomous Operator","Customers","Eventing","Kubernetes"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/","url":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/","name":"How to Build a Couchbase Autonomous Operator Proof of Concept","isPartOf":{"@id":"https:\/\/www.couchbase.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage"},"thumbnailUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg","datePublished":"2021-07-05T10:47:22+00:00","dateModified":"2025-06-14T05:39:23+00:00","description":"Discover how to quickly build a Proof of Concept (PoC) environment for the Couchbase Autonomous Operator for Kubernetes in this walkthrough developer guide.","breadcrumb":{"@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#primaryimage","url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg","contentUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2021\/07\/Couchbase-Autonomous-Operator-cao-Proof-of-Concept-guide.jpg","width":1200,"height":628,"caption":"Learn how to easily build a PoC Kubernetes environment to test out the Couchbase Autonomous Operator"},{"@type":"BreadcrumbList","@id":"https:\/\/www.couchbase.com\/blog\/couchbase-autonomous-operator-proof-of-concept-guide\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.couchbase.com\/blog\/"},{"@type":"ListItem","position":2,"name":"How to Build a Couchbase Autonomous Operator Proof of Concept"}]},{"@type":"WebSite","@id":"https:\/\/www.couchbase.com\/blog\/#website","url":"https:\/\/www.couchbase.com\/blog\/","name":"The Couchbase Blog","description":"Couchbase, the NoSQL Database","publisher":{"@id":"https:\/\/www.couchbase.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.couchbase.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.couchbase.com\/blog\/#organization","name":"The Couchbase Blog","url":"https:\/\/www.couchbase.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png","contentUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png","width":218,"height":34,"caption":"The Couchbase Blog"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/512e4ed8ed1188a93cb7c3aee277f408","name":"Sam Redman","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/image\/69dc9b1e46ceb237d29e1e4b626c6bcc","url":"https:\/\/secure.gravatar.com\/avatar\/ee34f7b9f2c46328736cdab03babdfd5ddc97cdd4a12ddd4b1b2d0f455eba51d?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/ee34f7b9f2c46328736cdab03babdfd5ddc97cdd4a12ddd4b1b2d0f455eba51d?s=96&d=mm&r=g","caption":"Sam Redman"},"description":"Solutions Engineer at Couchbase. Sam has previously as a developer and an SRE before joining Couchbase.","url":"https:\/\/www.couchbase.com\/blog\/author\/sam-redman\/"}]}},"authors":[{"term_id":9168,"user_id":76077,"is_guest":0,"slug":"sam-redman","display_name":"Sam Redman, Solutions Engineer","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/ee34f7b9f2c46328736cdab03babdfd5ddc97cdd4a12ddd4b1b2d0f455eba51d?s=96&d=mm&r=g","author_category":"","last_name":"Redman","first_name":"Sam","job_title":"","user_url":"","description":"Sam Redman is a Solutions Engineer at Couchbase. Sam previously worked in development and SRE environments before joining Couchbase."}],"_links":{"self":[{"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/posts\/11365","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/users\/76077"}],"replies":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/comments?post=11365"}],"version-history":[{"count":0,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/posts\/11365\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/media\/11492"}],"wp:attachment":[{"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/media?parent=11365"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/categories?post=11365"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/tags?post=11365"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/wp-json\/wp\/v2\/ppma_author?post=11365"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}