{"id":594,"date":"2026-04-14T16:13:08","date_gmt":"2026-04-14T16:13:08","guid":{"rendered":"https:\/\/www.devopsschool.com\/tutorials\/google-cloud-code-for-intellij-tutorial-architecture-pricing-use-cases-and-hands-on-guide-for-application-development\/"},"modified":"2026-04-14T16:13:08","modified_gmt":"2026-04-14T16:13:08","slug":"google-cloud-code-for-intellij-tutorial-architecture-pricing-use-cases-and-hands-on-guide-for-application-development","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/tutorials\/google-cloud-code-for-intellij-tutorial-architecture-pricing-use-cases-and-hands-on-guide-for-application-development\/","title":{"rendered":"Google Cloud Code for IntelliJ Tutorial: Architecture, Pricing, Use Cases, and Hands-On Guide for Application development"},"content":{"rendered":"\n<h2 class=\"wp-block-heading\">Category<\/h2>\n\n\n\n<p>Application development<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">1. Introduction<\/h2>\n\n\n\n<p>Cloud Code for IntelliJ is a Google-provided IDE plugin that helps you build, iterate, and troubleshoot containerized applications\u2014especially Kubernetes applications\u2014directly from IntelliJ IDEA and other IntelliJ-based IDEs.<\/p>\n\n\n\n<p>In simple terms: it brings \u201cinner-loop\u201d cloud-native development into your IDE. Instead of manually running long command sequences to build container images, deploy them to a cluster, watch logs, and repeat, Cloud Code for IntelliJ streamlines those workflows and connects them to familiar IntelliJ run\/debug actions.<\/p>\n\n\n\n<p>Technically, Cloud Code for IntelliJ integrates your IDE with common Kubernetes and container tools (most notably <a href=\"https:\/\/skaffold.dev\/\">Skaffold<\/a> and <code>kubectl<\/code>) to enable repeatable build\/deploy cycles, YAML authoring assistance, cluster interaction, and (in supported configurations) debugging against workloads running in Kubernetes. It is a developer tool installed on your workstation\u2014not a hosted Google Cloud service\u2014so it relies heavily on your local toolchain and on the target environment you deploy to (local Kubernetes, GKE, etc.).<\/p>\n\n\n\n<p>The problem it solves is friction: Kubernetes and cloud-native development often involves a lot of \u201cglue work\u201d (tool setup, manifests, rebuild\/redeploy cycles, context switching, and troubleshooting across terminals). Cloud Code for IntelliJ reduces that overhead so teams can ship changes faster while staying consistent with production-like workflows.<\/p>\n\n\n\n<blockquote>\n<p>Naming note: Google has historically used names like \u201cGoogle Cloud Tools for IntelliJ.\u201d Today, \u201cCloud Code\u201d is the name used in current Google Cloud documentation for these IDE extensions. Verify the latest naming and support status in the official docs for your IDE version: https:\/\/cloud.google.com\/code\/docs\/intellij<\/p>\n<\/blockquote>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">2. What is Cloud Code for IntelliJ?<\/h2>\n\n\n\n<p>Cloud Code for IntelliJ is an IDE extension from Google Cloud that supports cloud-native application development workflows inside IntelliJ-based IDEs. Its official purpose is to help developers create, edit, run, and troubleshoot applications destined for Kubernetes (and related container-based platforms) with less manual setup and fewer context switches.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Core capabilities (high-level)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Kubernetes-focused inner-loop development<\/strong> using Skaffold-driven build and deploy loops.<\/li>\n<li><strong>Kubernetes configuration authoring assistance<\/strong> (editing, validation, and navigation for YAML).<\/li>\n<li><strong>Cluster interaction from the IDE<\/strong> (view resources, fetch logs, port-forward, etc., depending on plugin version and configuration).<\/li>\n<li><strong>Run\/debug integration<\/strong> that connects IntelliJ run configurations to container\/Kubernetes workflows (backed by Skaffold).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Major components<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Cloud Code plugin<\/strong> installed in IntelliJ (JetBrains Marketplace distribution).<\/li>\n<li><strong>Local developer tools<\/strong> typically used underneath:<\/li>\n<li><code>kubectl<\/code> (Kubernetes CLI)<\/li>\n<li>Skaffold (build\/deploy orchestration)<\/li>\n<li>A container build system (often Docker; sometimes Cloud Build via Skaffold configuration)<\/li>\n<li>Access to a Kubernetes cluster (local or remote such as Google Kubernetes Engine)<\/li>\n<\/ul>\n\n\n\n<p>Cloud Code may help you install or manage some dependencies (for example Skaffold), depending on version and IDE; verify in official docs for your exact version.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Service type<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Client-side developer tool (IDE plugin)<\/strong>, not a managed runtime service.<\/li>\n<li>It does not \u201crun in a region\u201d the way compute services do. Your deployments are regional\/zonal depending on the target (for example, a GKE cluster\u2019s location).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Scope (how it\u2019s \u201cscoped\u201d)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Workstation-scoped<\/strong>: installed per developer machine and per IDE installation.<\/li>\n<li><strong>Identity-scoped<\/strong>: actions against Google Cloud use the developer\u2019s credentials (commonly via Google Cloud CLI authentication and\/or Application Default Credentials).<\/li>\n<li><strong>Project-scoped (indirectly)<\/strong>: operations target whichever Google Cloud project your tooling is configured to use (for example <code>gcloud config set project<\/code>, and whichever cluster context is active in <code>kubeconfig<\/code>).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">How it fits into the Google Cloud ecosystem<\/h3>\n\n\n\n<p>Cloud Code for IntelliJ sits in the <strong>Application development<\/strong> layer. It complements (not replaces) services like:\n&#8211; <strong>Google Kubernetes Engine (GKE)<\/strong> for running Kubernetes workloads.\n&#8211; <strong>Artifact Registry<\/strong> for storing container images.\n&#8211; <strong>Cloud Build<\/strong> for building images in the cloud (when configured via Skaffold).\n&#8211; <strong>Cloud Logging \/ Cloud Monitoring<\/strong> for observing running services.<\/p>\n\n\n\n<p>Cloud Code for IntelliJ is best thought of as \u201cdeveloper productivity glue\u201d that helps teams apply Google Cloud best practices from day one while keeping the workflow close to upstream Kubernetes tooling.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">3. Why use Cloud Code for IntelliJ?<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Business reasons<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Faster iteration cycles<\/strong>: Reduce build\/deploy friction so developers can test changes quickly.<\/li>\n<li><strong>More consistent developer workflows<\/strong>: Standardize how teams run and deploy Kubernetes apps locally and to shared clusters.<\/li>\n<li><strong>Shorter onboarding time<\/strong>: New engineers can be productive faster with IDE-integrated workflows and fewer tribal-knowledge scripts.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Technical reasons<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Skaffold-driven workflows<\/strong>: Skaffold is a widely used tool for repeatable Kubernetes build\/deploy loops. Cloud Code leverages that rather than inventing a proprietary pipeline.<\/li>\n<li><strong>Kubernetes-native development<\/strong>: Encourages manifests, deployments, and service definitions that more closely reflect how things run in production.<\/li>\n<li><strong>Tighter IDE integration<\/strong>: Developers can keep their flow in IntelliJ (run configs, logs, navigation) rather than living entirely in terminals.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Operational reasons<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Promotes repeatability<\/strong>: A repo-based <code>skaffold.yaml<\/code> and Kubernetes manifests reduce \u201cworks on my machine\u201d issues.<\/li>\n<li><strong>Better handoff to CI\/CD<\/strong>: The same container build and deploy definitions can often be reused (or mirrored) in CI pipelines.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Security \/ compliance reasons<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Leverages standard IAM + Kubernetes RBAC<\/strong>: Access to GKE and Google Cloud resources is controlled by existing identity and authorization layers.<\/li>\n<li><strong>Encourages fewer ad-hoc credentials<\/strong>: Teams can standardize on Google Cloud CLI auth flows, workload identity patterns, and secret managers rather than embedding secrets in dev scripts.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Scalability \/ performance reasons<\/h3>\n\n\n\n<p>Cloud Code for IntelliJ does not directly make your runtime scale; it improves how reliably you <em>develop and ship<\/em> scalable services by:\n&#8211; Making it easier to test container builds early\n&#8211; Encouraging Kubernetes-friendly config patterns\n&#8211; Reducing drift between local\/dev and cluster behavior<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">When teams should choose Cloud Code for IntelliJ<\/h3>\n\n\n\n<p>Choose it when:\n&#8211; You develop <strong>Kubernetes applications<\/strong> (especially targeting <strong>GKE<\/strong>) and want an IDE-first loop.\n&#8211; Your team uses <strong>IntelliJ-based IDEs<\/strong> and wants a supported Google Cloud plugin.\n&#8211; You want to standardize inner-loop tooling around <strong>Skaffold + kubectl<\/strong>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">When teams should not choose it<\/h3>\n\n\n\n<p>Avoid or reconsider if:\n&#8211; You are not building for Kubernetes\/containers (Cloud Code will add little value).\n&#8211; Your organization standardizes on a different IDE ecosystem (for example, VS Code only).\n&#8211; You cannot install local dev tooling (corporate restrictions) and you rely on hosted dev environments\u2014consider Cloud-based IDE workflows instead (for example Cloud Workstations), but verify Cloud Code compatibility and current options in official docs.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">4. Where is Cloud Code for IntelliJ used?<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Industries<\/h3>\n\n\n\n<p>Cloud Code for IntelliJ is common anywhere Kubernetes is common:\n&#8211; SaaS and technology companies\n&#8211; Financial services and fintech (with strong audit controls)\n&#8211; Retail\/e-commerce\n&#8211; Media and gaming\n&#8211; Healthcare and life sciences (with compliance requirements)<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Team types<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Application development teams building microservices<\/li>\n<li>Platform engineering teams building \u201cgolden path\u201d templates<\/li>\n<li>DevOps\/SRE teams supporting developer tooling and CI\/CD<\/li>\n<li>Security teams reviewing developer workflows and access patterns<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Workloads<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Microservices on Kubernetes (HTTP APIs, background workers)<\/li>\n<li>Event-driven services (paired with Pub\/Sub, Kafka, etc.)<\/li>\n<li>Internal developer platforms (IDPs) that standardize deployment patterns<\/li>\n<li>Migration workloads moving from VMs to containers<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Architectures and deployment contexts<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Local development clusters (Minikube, kind, Docker Desktop Kubernetes)<\/li>\n<li>Shared dev\/staging clusters<\/li>\n<li>Production clusters on <strong>Google Kubernetes Engine (GKE)<\/strong><\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Production vs dev\/test usage<\/h3>\n\n\n\n<p>Cloud Code for IntelliJ is primarily a <strong>development-time tool<\/strong>. It should be used to:\n&#8211; Build and validate artifacts early\n&#8211; Rapidly test changes against Kubernetes\n&#8211; Troubleshoot issues in dev\/staging<\/p>\n\n\n\n<p>Production releases should still be governed by CI\/CD, approvals, and policy controls. Cloud Code can help create consistent configs, but it should not be the sole production deployment mechanism for regulated environments.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">5. Top Use Cases and Scenarios<\/h2>\n\n\n\n<p>Below are realistic scenarios where Cloud Code for IntelliJ fits well.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">1) Inner-loop Kubernetes development for microservices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Rebuilding images and redeploying to Kubernetes after every code change is slow and error-prone.<\/li>\n<li><strong>Why it fits:<\/strong> Cloud Code uses Skaffold to automate rebuild\/redeploy loops.<\/li>\n<li><strong>Example scenario:<\/strong> A team iterates on a Java API and wants each save to trigger a rebuild and rollout to a dev namespace.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">2) Developing services locally with production-like Kubernetes manifests<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Local \u201crun\u201d scripts diverge from how services run in production.<\/li>\n<li><strong>Why it fits:<\/strong> Cloud Code workflows center on Kubernetes manifests and container images.<\/li>\n<li><strong>Example scenario:<\/strong> Developers use Minikube and the same manifests that will later be used on GKE.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">3) Standardizing developer workflows across the team<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Each engineer has different scripts and commands; onboarding takes weeks.<\/li>\n<li><strong>Why it fits:<\/strong> A repo with <code>skaffold.yaml<\/code> becomes the standard entry point for run\/deploy.<\/li>\n<li><strong>Example scenario:<\/strong> Platform team provides a template repo with Cloud Code-friendly setup.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">4) Faster troubleshooting using logs and quick cluster navigation<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Engineers waste time switching between IDE and terminals to inspect pods and logs.<\/li>\n<li><strong>Why it fits:<\/strong> Cloud Code can expose Kubernetes resources and streamline log access (capabilities vary by version).<\/li>\n<li><strong>Example scenario:<\/strong> During a dev test, an engineer quickly inspects pod logs after a failed readiness probe.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">5) Kubernetes YAML authoring with validation and structure<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> YAML mistakes cause deployment failures and time-consuming debugging.<\/li>\n<li><strong>Why it fits:<\/strong> IDE assistance for Kubernetes YAML reduces syntax and schema errors.<\/li>\n<li><strong>Example scenario:<\/strong> A developer adds liveness\/readiness probes and catches schema issues before applying.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">6) Multi-environment deployments via Skaffold profiles<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Dev\/staging\/prod environments require different settings and image registries.<\/li>\n<li><strong>Why it fits:<\/strong> Skaffold profiles can capture environment differences cleanly.<\/li>\n<li><strong>Example scenario:<\/strong> <code>profile=dev<\/code> deploys to Minikube; <code>profile=gke<\/code> pushes to Artifact Registry and deploys to a GKE namespace.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">7) Developing on GKE with proper IAM and RBAC<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Teams need controlled access to shared clusters.<\/li>\n<li><strong>Why it fits:<\/strong> Cloud Code uses standard auth paths (<code>gcloud<\/code>, kubeconfig), fitting enterprise controls.<\/li>\n<li><strong>Example scenario:<\/strong> Developers have read-only access in staging and full deploy rights in dev namespaces.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">8) Building containers in the cloud (Cloud Build) from the same workflow<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Developer laptops can\u2019t build large images reliably or quickly.<\/li>\n<li><strong>Why it fits:<\/strong> Skaffold can be configured to use Cloud Build; Cloud Code runs the same definitions.<\/li>\n<li><strong>Example scenario:<\/strong> A monorepo uses Cloud Build for consistent builds across OS environments.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">9) Artifact Registry integration patterns for container images<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Teams need a secure place to store images and control access.<\/li>\n<li><strong>Why it fits:<\/strong> The workflow naturally pushes images to a registry used by GKE.<\/li>\n<li><strong>Example scenario:<\/strong> Images are pushed to Artifact Registry with least-privilege access for devs and cluster nodes.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">10) Migration from legacy deployment scripts to Kubernetes-native workflows<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> Old shell scripts are brittle and hard to maintain.<\/li>\n<li><strong>Why it fits:<\/strong> Cloud Code encourages declarative config and tool-driven processes.<\/li>\n<li><strong>Example scenario:<\/strong> A team replaces \u201cSSH and restart\u201d scripts with Kubernetes Deployments and Skaffold.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">6. Core Features<\/h2>\n\n\n\n<p>Feature availability can vary by IDE version and plugin release. Always validate against official documentation for Cloud Code for IntelliJ: https:\/\/cloud.google.com\/code\/docs\/intellij<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">1) Skaffold-based build\/deploy\/run workflows<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Runs Skaffold to build container images and deploy Kubernetes manifests repeatedly during development.<\/li>\n<li><strong>Why it matters:<\/strong> Skaffold provides a repeatable, tool-agnostic loop.<\/li>\n<li><strong>Practical benefit:<\/strong> Fewer manual steps; consistent results across team members.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> Requires a working local toolchain (Docker, kubectl) and cluster access. Build behavior depends on Skaffold configuration.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">2) IDE run configurations for Kubernetes development<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Connects IntelliJ \u201cRun\/Debug\u201d to Kubernetes development tasks (often via Skaffold).<\/li>\n<li><strong>Why it matters:<\/strong> Keeps developers in one workflow and enables repeatability.<\/li>\n<li><strong>Practical benefit:<\/strong> One-click start\/stop of dev loops; easier onboarding.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> UI labels and exact configuration steps may vary across IntelliJ versions and plugin releases\u2014verify in your IDE.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">3) Kubernetes YAML editing support<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Helps you author Kubernetes resources (Deployments, Services, ConfigMaps, etc.) with IDE assistance.<\/li>\n<li><strong>Why it matters:<\/strong> Kubernetes YAML is verbose; mistakes are common.<\/li>\n<li><strong>Practical benefit:<\/strong> Catch errors early, improve correctness, speed up manifest authoring.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> Schema validation depends on your IDE\/plugin capabilities and the Kubernetes API versions you target.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">4) Kubernetes resource exploration (cluster interaction)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Provides ways to view and interact with cluster resources from within the IDE (for example, viewing workloads, logs, or describing resources).<\/li>\n<li><strong>Why it matters:<\/strong> Reduces context switching between IDE and terminal.<\/li>\n<li><strong>Practical benefit:<\/strong> Faster troubleshooting loops during development.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> Some actions may still require <code>kubectl<\/code> and correct kubeconfig context; capabilities can differ by version.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">5) Log access and basic troubleshooting workflows<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Surfaces container logs and status information to aid debugging.<\/li>\n<li><strong>Why it matters:<\/strong> Logs are often the quickest route to root cause in Kubernetes.<\/li>\n<li><strong>Practical benefit:<\/strong> Less time hunting for the right pod or label selector.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> Large log volume can incur costs in managed logging backends; access is controlled by RBAC\/IAM.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">6) Toolchain alignment (kubectl, contexts, credentials)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Works with your configured Kubernetes contexts and your Google Cloud authentication.<\/li>\n<li><strong>Why it matters:<\/strong> Enterprises need controlled access without bypassing IAM.<\/li>\n<li><strong>Practical benefit:<\/strong> Fits existing security governance: IAM + RBAC + audit logging.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> If authentication plugins (for example, the GKE gcloud auth plugin) are missing or misconfigured, cluster access fails.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">7) Support for local and remote clusters<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Lets you run the same dev workflow on local clusters (Minikube\/kind) and remote clusters (like GKE), depending on your kubeconfig context.<\/li>\n<li><strong>Why it matters:<\/strong> Local-first is cheaper; remote is more production-like.<\/li>\n<li><strong>Practical benefit:<\/strong> Choose the right environment per task.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> Remote clusters add latency and cost, and require stronger access controls.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">8) Works well with Git-based workflows<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>What it does:<\/strong> Keeps most \u201chow to build\/deploy\u201d knowledge in repo files (<code>skaffold.yaml<\/code>, manifests, Dockerfile).<\/li>\n<li><strong>Why it matters:<\/strong> Versioned configuration supports review and compliance.<\/li>\n<li><strong>Practical benefit:<\/strong> CI systems can reuse the same definitions.<\/li>\n<li><strong>Limitations\/caveats:<\/strong> Requires discipline to keep configs clean and environment-appropriate.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">7. Architecture and How It Works<\/h2>\n\n\n\n<p>Cloud Code for IntelliJ is best understood as an IDE layer over established Kubernetes tooling.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">High-level architecture<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>The developer edits code and Kubernetes manifests in IntelliJ.<\/li>\n<li>Cloud Code triggers Skaffold operations (build, deploy, dev loop).<\/li>\n<li>Skaffold uses a builder (often Docker; optionally Cloud Build if configured) to produce container images.<\/li>\n<li>Skaffold deploys Kubernetes manifests using kubectl (or other deployers depending on Skaffold config).<\/li>\n<li>The Kubernetes cluster schedules pods, runs containers, and exposes services.<\/li>\n<li>Logs and status are retrieved from Kubernetes and (optionally) Google Cloud observability services.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Request\/data\/control flow (typical dev loop)<\/h3>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Developer clicks <strong>Run<\/strong> (or starts a dev loop).<\/li>\n<li>Cloud Code calls Skaffold with the repo\u2019s <code>skaffold.yaml<\/code>.<\/li>\n<li>Skaffold builds the container image.<\/li>\n<li>Skaffold applies manifests to the target cluster.<\/li>\n<li>Developer tests the service (often via port-forward or an ingress).<\/li>\n<li>Developer changes code; Skaffold detects changes and repeats the cycle.<\/li>\n<\/ol>\n\n\n\n<h3 class=\"wp-block-heading\">Integrations with related services<\/h3>\n\n\n\n<p>Cloud Code itself is not the integration point; <strong>your workflow<\/strong> integrates with services through:\n&#8211; <strong>GKE<\/strong> as the runtime (Kubernetes control plane and nodes)\n&#8211; <strong>Artifact Registry<\/strong> as the image registry\n&#8211; <strong>Cloud Build<\/strong> as an optional cloud build backend (via Skaffold configuration)\n&#8211; <strong>Cloud Logging\/Monitoring<\/strong> for production-grade observability (recommended for real environments)<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Dependency services and tools<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Kubernetes cluster (local or GKE)<\/li>\n<li>Skaffold installed locally (or managed by the plugin, depending on version)<\/li>\n<li>kubectl installed locally<\/li>\n<li>Container build tool (Docker) or cloud build backend<\/li>\n<li>Google Cloud CLI (<code>gcloud<\/code>) for authenticating to Google Cloud and (for GKE) fetching cluster credentials<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Security\/authentication model<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Google Cloud identity<\/strong>: Typically via <code>gcloud auth login<\/code> for user credentials.<\/li>\n<li><strong>Cluster auth<\/strong>:<\/li>\n<li>For GKE: kubeconfig entries obtained via <code>gcloud container clusters get-credentials<\/code> and authenticated via the appropriate GKE auth plugin.<\/li>\n<li>For local clusters: kubeconfig points to local API server.<\/li>\n<li><strong>Authorization<\/strong>:<\/li>\n<li>Google Cloud IAM controls who can access GKE APIs, Artifact Registry, Cloud Build, etc.<\/li>\n<li>Kubernetes RBAC controls who can perform actions in the cluster (namespaces, deployments, logs).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Networking model<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Cloud Code runs locally and talks to:<\/li>\n<li>Kubernetes API server (local or remote)<\/li>\n<li>Container registry endpoints (Artifact Registry) when pushing images<\/li>\n<li>Cloud Build APIs if configured<\/li>\n<li>For testing services, common patterns include:<\/li>\n<li><code>kubectl port-forward<\/code> to localhost<\/li>\n<li>Ingress\/Gateway in a shared cluster<\/li>\n<li>LoadBalancer services (costly in cloud environments)<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Monitoring\/logging\/governance considerations<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Dev clusters: basic logs via kubectl are often enough.<\/li>\n<li>Shared\/prod clusters: centralize logs\/metrics in Cloud Logging\/Monitoring with retention and access policies.<\/li>\n<li>Governance: treat <code>skaffold.yaml<\/code> and manifests like production artifacts (code review, policy checks).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Simple architecture diagram (developer inner loop)<\/h3>\n\n\n\n<pre><code class=\"language-mermaid\">flowchart LR\n  Dev[Developer in IntelliJ] --&gt; CC[Cloud Code for IntelliJ]\n  CC --&gt;|invokes| Skaffold[Skaffold]\n  Skaffold --&gt;|build| Docker[Local Docker Engine]\n  Skaffold --&gt;|deploy via kubectl| K8s[Kubernetes Cluster\\n(Local or GKE)]\n  Dev --&gt;|test via localhost| PortFwd[Port-forward \/ Local URL]\n  K8s --&gt; Logs[Pod Logs \/ Events]\n  Logs --&gt; Dev\n<\/code><\/pre>\n\n\n\n<h3 class=\"wp-block-heading\">Production-style architecture diagram (inner loop + CI\/CD + platform services)<\/h3>\n\n\n\n<pre><code class=\"language-mermaid\">flowchart TB\n  subgraph DevWorkstation[\"Developer Workstation\"]\n    IDE[IntelliJ + Cloud Code]\n    Skaffold2[Skaffold\/kubectl]\n  end\n\n  subgraph GoogleCloud[\"Google Cloud\"]\n    AR[Artifact Registry]\n    GKE[GKE Cluster]\n    CB[Cloud Build (optional via Skaffold\/CI)]\n    CL[Cloud Logging]\n    CM[Cloud Monitoring]\n    IAM[IAM + Org Policies]\n  end\n\n  subgraph GitOps[\"Source Control \/ CI\"]\n    Git[Git Repository]\n    CI[CI Pipeline\\n(build\/test\/scan)]\n  end\n\n  IDE --&gt; Skaffold2\n  Skaffold2 --&gt;|build locally or via CB| CB\n  Skaffold2 --&gt;|push image| AR\n  Skaffold2 --&gt;|apply manifests| GKE\n\n  Git --&gt; CI\n  CI --&gt; CB\n  CB --&gt; AR\n  CI --&gt;|deploy (CD)| GKE\n\n  GKE --&gt; CL\n  GKE --&gt; CM\n  IAM --&gt; GKE\n  IAM --&gt; AR\n  IAM --&gt; CB\n<\/code><\/pre>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">8. Prerequisites<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Account\/project requirements<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>A <strong>Google Cloud account<\/strong>.<\/li>\n<li>A <strong>Google Cloud project<\/strong> (recommended even if you start locally, because most teams eventually target GKE\/Artifact Registry).<\/li>\n<li>Billing enabled if you will use paid services (GKE, Artifact Registry beyond free quotas, Cloud Build, logging beyond free allotments, etc.).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Permissions \/ IAM roles (common minimums)<\/h3>\n\n\n\n<p>Exact roles depend on what you do. Common needs:\n&#8211; For GKE cluster access:\n  &#8211; <code>roles\/container.clusterViewer<\/code> (view clusters) and\/or <code>roles\/container.developer<\/code> (deploy to clusters)\n  &#8211; Kubernetes RBAC permissions in the cluster namespace\n&#8211; For Artifact Registry:\n  &#8211; <code>roles\/artifactregistry.writer<\/code> (push images) and <code>roles\/artifactregistry.reader<\/code> (pull images)\n&#8211; For Cloud Build (if used):\n  &#8211; <code>roles\/cloudbuild.builds.editor<\/code> or a more restricted custom role<\/p>\n\n\n\n<p>Use least privilege and prefer group-based access. Verify with your security team and official IAM docs.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Tools you\u2019ll typically need<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>IntelliJ IDEA (Community or Ultimate depending on your language needs)<\/li>\n<li><strong>Cloud Code for IntelliJ<\/strong> plugin (JetBrains Marketplace)<\/li>\n<li>Google Cloud CLI (<code>gcloud<\/code>): https:\/\/cloud.google.com\/sdk\/docs\/install<\/li>\n<li>Kubernetes CLI (<code>kubectl<\/code>): https:\/\/kubernetes.io\/docs\/tasks\/tools\/<\/li>\n<li>Skaffold: https:\/\/skaffold.dev\/docs\/install\/ (may be managed by plugin; verify)<\/li>\n<li>A local container runtime (commonly Docker Desktop)<\/li>\n<li>Access to a Kubernetes cluster:<\/li>\n<li>Local: Minikube or kind<\/li>\n<li>Remote: GKE (optional for the lab, but common for real use)<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Region availability<\/h3>\n\n\n\n<p>Cloud Code for IntelliJ itself is not region-bound. Region constraints apply to the services you use (GKE, Artifact Registry, Cloud Build). Check product-specific locations:\n&#8211; GKE locations: https:\/\/cloud.google.com\/kubernetes-engine\/docs\/concepts\/types-of-clusters#location\n&#8211; Artifact Registry locations: https:\/\/cloud.google.com\/artifact-registry\/docs\/repositories\/repo-locations<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Quotas\/limits<\/h3>\n\n\n\n<p>Cloud Code has no \u201cquota\u201d in the cloud-service sense, but you can hit:\n&#8211; GKE quotas (clusters, nodes, IPs)\n&#8211; Artifact Registry quotas (storage, requests)\n&#8211; Cloud Build quotas (build minutes, concurrency)\n&#8211; Cloud Logging ingestion\/retention constraints<\/p>\n\n\n\n<p>Always verify quotas in the Google Cloud Console for your project.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Prerequisite services (if deploying to Google Cloud)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>GKE API enabled (if using GKE)<\/li>\n<li>Artifact Registry API enabled (if pushing images)<\/li>\n<li>Cloud Build API enabled (if using Cloud Build)<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">9. Pricing \/ Cost<\/h2>\n\n\n\n<p>Cloud Code for IntelliJ is generally available <strong>at no additional charge<\/strong> as an IDE plugin. There is no \u201cCloud Code runtime\u201d that you pay for.<\/p>\n\n\n\n<p>However, Cloud Code-driven workflows commonly create costs in other Google Cloud services.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Pricing dimensions (where costs actually come from)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Compute<\/strong>:<\/li>\n<li>GKE nodes (Compute Engine VMs) or GKE Autopilot resources<\/li>\n<li>Any load balancers created by Kubernetes Services of type <code>LoadBalancer<\/code><\/li>\n<li><strong>Container image storage and requests<\/strong>:<\/li>\n<li>Artifact Registry storage (GB-month) and operations (pulls\/pushes)<\/li>\n<li><strong>Build costs<\/strong>:<\/li>\n<li>Cloud Build build minutes (if you configure Skaffold to build in Cloud Build)<\/li>\n<li><strong>Observability<\/strong>:<\/li>\n<li>Cloud Logging ingestion, retention, and log-based metrics<\/li>\n<li>Cloud Monitoring metrics and uptime checks<\/li>\n<li><strong>Networking<\/strong>:<\/li>\n<li>Egress traffic from GKE to the internet or across regions<\/li>\n<li>Load balancer data processing (if applicable)<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Free tier (what to expect)<\/h3>\n\n\n\n<p>Free tiers change over time and vary by product. Cloud Code itself doesn\u2019t have a metered free tier, but other services may.\n&#8211; Check the Google Cloud Free Program: https:\/\/cloud.google.com\/free\n&#8211; Use the Google Cloud Pricing Calculator for estimates: https:\/\/cloud.google.com\/products\/calculator<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Cost drivers (most common surprises)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Leaving a GKE cluster running<\/strong> (nodes cost money continuously).<\/li>\n<li><strong>Using <code>LoadBalancer<\/code> services in dev<\/strong> (provisions billable load balancers).<\/li>\n<li><strong>High log volume<\/strong> from chatty services.<\/li>\n<li><strong>Large image layers<\/strong> pushed frequently during iterative development.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Hidden\/indirect costs<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Developer time: inefficient inner loops can be more expensive than infrastructure.<\/li>\n<li>CI duplication: building locally + building again in CI if not aligned.<\/li>\n<li>Storage sprawl: unused images piling up in registries.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Cost optimization tips<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Prefer <strong>local clusters<\/strong> (Minikube\/kind) for most development.<\/li>\n<li>Use <strong>port-forward<\/strong> instead of cloud load balancers during development.<\/li>\n<li>Use <strong>Skaffold file sync<\/strong> where applicable to avoid full rebuilds (verify support and configuration).<\/li>\n<li>Clean up unused images and set Artifact Registry cleanup policies (verify current feature set in Artifact Registry docs).<\/li>\n<li>Keep images small (multi-stage builds, minimal base images).<\/li>\n<li>For shared clusters, use namespaces and resource quotas to prevent runaway usage.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Example low-cost starter estimate (conceptual)<\/h3>\n\n\n\n<p>A low-cost start often looks like:\n&#8211; Local Kubernetes cluster (no cloud compute)\n&#8211; No external load balancers\n&#8211; Optional: a small Artifact Registry repo used sparingly<\/p>\n\n\n\n<p>Your primary costs may be near zero until you deploy to GKE or use paid build\/registry\/observability features. Exact costs depend on usage and region\u2014use the calculator.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Example production cost considerations<\/h3>\n\n\n\n<p>In production-like environments:\n&#8211; GKE cluster sizing, node pools, and autoscaling dominate compute costs.\n&#8211; Centralized logging\/metrics plus retention can be significant.\n&#8211; Artifact Registry storage and high pull traffic can add up.\n&#8211; CI builds and security scanning (if done in Cloud Build or other services) add predictable pipeline costs.<\/p>\n\n\n\n<p>Official references:\n&#8211; Pricing landing page: https:\/\/cloud.google.com\/pricing\n&#8211; Pricing calculator: https:\/\/cloud.google.com\/products\/calculator\n&#8211; Artifact Registry pricing: https:\/\/cloud.google.com\/artifact-registry\/pricing\n&#8211; GKE pricing: https:\/\/cloud.google.com\/kubernetes-engine\/pricing\n&#8211; Cloud Build pricing: https:\/\/cloud.google.com\/build\/pricing<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">10. Step-by-Step Hands-On Tutorial<\/h2>\n\n\n\n<p>This lab focuses on a safe, low-cost workflow: <strong>developing a Kubernetes app locally<\/strong> (Minikube) using <strong>Cloud Code for IntelliJ + Skaffold<\/strong>. You can adapt the same project to deploy to <strong>GKE<\/strong> afterward.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Objective<\/h3>\n\n\n\n<p>Set up Cloud Code for IntelliJ and use it to run an iterative development loop for a simple containerized web service on a local Kubernetes cluster using Skaffold.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Lab Overview<\/h3>\n\n\n\n<p>You will:\n1. Install prerequisites (Minikube, kubectl, Skaffold, gcloud).\n2. Install Cloud Code for IntelliJ.\n3. Create a small containerized app with Kubernetes manifests and a <code>skaffold.yaml<\/code>.\n4. Run a dev loop (rebuild\/redeploy on change).\n5. Validate using port-forward.\n6. Clean up.<\/p>\n\n\n\n<p>This lab is designed to be runnable without provisioning paid Google Cloud resources. (If you later deploy to GKE, that will incur charges.)<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 1: Install and verify local tooling<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">1.1 Install Google Cloud CLI (optional but recommended)<\/h4>\n\n\n\n<p>Follow: https:\/\/cloud.google.com\/sdk\/docs\/install<\/p>\n\n\n\n<p>Authenticate (optional for local-only, required for GKE later):<\/p>\n\n\n\n<pre><code class=\"language-bash\">gcloud auth login\ngcloud auth application-default login\n<\/code><\/pre>\n\n\n\n<p>Set a default project (optional now; required for GKE later):<\/p>\n\n\n\n<pre><code class=\"language-bash\">gcloud config set project YOUR_PROJECT_ID\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; <code>gcloud version<\/code> works\n&#8211; You can authenticate successfully if needed<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">1.2 Install Docker<\/h4>\n\n\n\n<p>Install Docker Desktop (or Docker Engine on Linux) and ensure it\u2019s running.<\/p>\n\n\n\n<p>Verify:<\/p>\n\n\n\n<pre><code class=\"language-bash\">docker version\ndocker ps\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; Docker daemon is running and responds<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">1.3 Install kubectl<\/h4>\n\n\n\n<p>Install instructions: https:\/\/kubernetes.io\/docs\/tasks\/tools\/<\/p>\n\n\n\n<p>Verify:<\/p>\n\n\n\n<pre><code class=\"language-bash\">kubectl version --client=true\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; kubectl client prints version info<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">1.4 Install Minikube<\/h4>\n\n\n\n<p>Install: https:\/\/minikube.sigs.k8s.io\/docs\/start\/<\/p>\n\n\n\n<p>Start Minikube (Docker driver shown as a common option; choose what fits your OS):<\/p>\n\n\n\n<pre><code class=\"language-bash\">minikube start --driver=docker\n<\/code><\/pre>\n\n\n\n<p>Verify:<\/p>\n\n\n\n<pre><code class=\"language-bash\">kubectl get nodes\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; One node appears in <code>Ready<\/code> state<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">1.5 Install Skaffold<\/h4>\n\n\n\n<p>Install: https:\/\/skaffold.dev\/docs\/install\/<\/p>\n\n\n\n<p>Verify:<\/p>\n\n\n\n<pre><code class=\"language-bash\">skaffold version\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; Skaffold prints a version<\/p>\n\n\n\n<blockquote>\n<p>Note: Some Cloud Code versions can manage Skaffold for you. Even if that\u2019s true, having a known-good CLI install makes troubleshooting much easier.<\/p>\n<\/blockquote>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 2: Install Cloud Code for IntelliJ<\/h3>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Open IntelliJ IDEA.<\/li>\n<li>Go to <strong>Settings\/Preferences \u2192 Plugins \u2192 Marketplace<\/strong>.<\/li>\n<li>Search for <strong>Cloud Code<\/strong>.<\/li>\n<li>Install <strong>Cloud Code for IntelliJ<\/strong> and restart the IDE when prompted.<\/li>\n<\/ol>\n\n\n\n<p>Expected outcome:\n&#8211; Cloud Code features appear in the IDE (for example, Cloud Code menus, Kubernetes-related run configurations, or tool windows). The exact UI can differ by version\u2014verify with official docs: https:\/\/cloud.google.com\/code\/docs\/intellij<\/p>\n\n\n\n<p>Verification:\n&#8211; In IntelliJ, confirm the plugin is listed as installed and enabled.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 3: Create a sample Kubernetes app project<\/h3>\n\n\n\n<p>Create a new folder, for example <code>cloudcode-intellij-lab\/<\/code>, with the following structure:<\/p>\n\n\n\n<pre><code class=\"language-text\">cloudcode-intellij-lab\/\n  app\/\n    main.py\n    requirements.txt\n  Dockerfile\n  k8s\/\n    deployment.yaml\n    service.yaml\n  skaffold.yaml\n<\/code><\/pre>\n\n\n\n<h4 class=\"wp-block-heading\">3.1 Application code (Python Flask)<\/h4>\n\n\n\n<p>Create <code>app\/requirements.txt<\/code>:<\/p>\n\n\n\n<pre><code class=\"language-text\">Flask==3.0.0\ngunicorn==21.2.0\n<\/code><\/pre>\n\n\n\n<p>Create <code>app\/main.py<\/code>:<\/p>\n\n\n\n<pre><code class=\"language-python\">from flask import Flask\nimport os\n\napp = Flask(__name__)\n\n@app.get(\"\/\")\ndef hello():\n    target = os.environ.get(\"TARGET\", \"world\")\n    return f\"Hello, {target}!\\n\"\n\nif __name__ == \"__main__\":\n    # For local runs only; container uses gunicorn\n    app.run(host=\"0.0.0.0\", port=8080)\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; A minimal HTTP service that responds on <code>\/<\/code><\/p>\n\n\n\n<h4 class=\"wp-block-heading\">3.2 Dockerfile<\/h4>\n\n\n\n<p>Create <code>Dockerfile<\/code>:<\/p>\n\n\n\n<pre><code class=\"language-dockerfile\">FROM python:3.12-slim\n\nWORKDIR \/app\nCOPY app\/requirements.txt \/app\/\nRUN pip install --no-cache-dir -r requirements.txt\n\nCOPY app\/ \/app\/\n\nENV PORT=8080\nEXPOSE 8080\n\nCMD [\"gunicorn\", \"--bind\", \"0.0.0.0:8080\", \"main:app\"]\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; Container image that runs the Flask app on port 8080<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">3.3 Kubernetes manifests<\/h4>\n\n\n\n<p>Create <code>k8s\/deployment.yaml<\/code>:<\/p>\n\n\n\n<pre><code class=\"language-yaml\">apiVersion: apps\/v1\nkind: Deployment\nmetadata:\n  name: hello\n  labels:\n    app: hello\nspec:\n  replicas: 1\n  selector:\n    matchLabels:\n      app: hello\n  template:\n    metadata:\n      labels:\n        app: hello\n    spec:\n      containers:\n      - name: hello\n        image: hello:dev\n        ports:\n        - containerPort: 8080\n        env:\n        - name: TARGET\n          value: \"Cloud Code for IntelliJ\"\n<\/code><\/pre>\n\n\n\n<p>Create <code>k8s\/service.yaml<\/code>:<\/p>\n\n\n\n<pre><code class=\"language-yaml\">apiVersion: v1\nkind: Service\nmetadata:\n  name: hello\nspec:\n  selector:\n    app: hello\n  ports:\n  - name: http\n    port: 8080\n    targetPort: 8080\n    protocol: TCP\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; Deployment and Service definitions that will run in Kubernetes<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">3.4 Skaffold configuration<\/h4>\n\n\n\n<p>Create <code>skaffold.yaml<\/code>:<\/p>\n\n\n\n<pre><code class=\"language-yaml\">apiVersion: skaffold\/v4beta6\nkind: Config\nmetadata:\n  name: hello\nbuild:\n  artifacts:\n  - image: hello\n    docker:\n      dockerfile: Dockerfile\nmanifests:\n  rawYaml:\n  - k8s\/deployment.yaml\n  - k8s\/service.yaml\nportForward:\n- resourceType: service\n  resourceName: hello\n  port: 8080\n  localPort: 8080\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; Skaffold can build the Docker image, apply manifests, and port-forward the Service to <code>localhost:8080<\/code>.<\/p>\n\n\n\n<blockquote>\n<p>If your installed Skaffold version does not support <code>v4beta6<\/code>, adjust the <code>apiVersion<\/code> to match your Skaffold version. Use <code>skaffold fix<\/code> to migrate configs when needed. Verify in Skaffold docs: https:\/\/skaffold.dev\/docs\/<\/p>\n<\/blockquote>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 4: Open the project in IntelliJ and confirm Kubernetes context<\/h3>\n\n\n\n<ol class=\"wp-block-list\">\n<li>In IntelliJ: <strong>File \u2192 Open<\/strong> and open <code>cloudcode-intellij-lab\/<\/code>.<\/li>\n<li>Ensure your Kubernetes context points to Minikube:\n   <code>bash\n   kubectl config current-context<\/code>\n   If needed:\n   <code>bash\n   kubectl config use-context minikube<\/code><\/li>\n<\/ol>\n\n\n\n<p>Expected outcome:\n&#8211; IntelliJ has the project open\n&#8211; <code>kubectl<\/code> points to Minikube<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 5: Run the dev loop (Cloud Code + Skaffold)<\/h3>\n\n\n\n<p>You have two reliable ways to run. Use <strong>Option A<\/strong> if your Cloud Code UI matches; use <strong>Option B<\/strong> as a guaranteed fallback.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Option A (IDE-driven): Run Skaffold via Cloud Code run configuration<\/h4>\n\n\n\n<ol class=\"wp-block-list\">\n<li>In IntelliJ: <strong>Run \u2192 Edit Configurations<\/strong><\/li>\n<li>Add a new configuration of the Cloud Code Kubernetes\/Skaffold type (the exact name can vary; look for \u201cCloud Code\u201d and \u201cKubernetes\u201d).<\/li>\n<li>Point it at your <code>skaffold.yaml<\/code>.<\/li>\n<li>Choose a mode equivalent to <strong>Dev<\/strong> (continuous development).<\/li>\n<\/ol>\n\n\n\n<p>Start the configuration.<\/p>\n\n\n\n<p>Expected outcome:\n&#8211; You see Skaffold output in the IDE run console\n&#8211; A pod and service are created in the cluster<\/p>\n\n\n\n<p>Verify in a terminal:<\/p>\n\n\n\n<pre><code class=\"language-bash\">kubectl get deploy,po,svc\n<\/code><\/pre>\n\n\n\n<p>You should see resources named <code>hello<\/code>.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Option B (CLI fallback): Run Skaffold directly<\/h4>\n\n\n\n<p>From the project directory:<\/p>\n\n\n\n<pre><code class=\"language-bash\">skaffold dev\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:\n&#8211; Skaffold builds <code>hello<\/code> image and deploys it\n&#8211; Port-forward starts to <code>localhost:8080<\/code> (based on <code>portForward<\/code> config)<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 6: Validate the running service<\/h3>\n\n\n\n<p>In a new terminal, call the service:<\/p>\n\n\n\n<pre><code class=\"language-bash\">curl http:\/\/localhost:8080\/\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:<\/p>\n\n\n\n<pre><code class=\"language-text\">Hello, Cloud Code for IntelliJ!\n<\/code><\/pre>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Step 7: Make a change and watch the redeploy<\/h3>\n\n\n\n<p>Edit <code>app\/main.py<\/code> and change the greeting:<\/p>\n\n\n\n<pre><code class=\"language-python\">return f\"Hello from Kubernetes, {target}!\\n\"\n<\/code><\/pre>\n\n\n\n<p>Save the file.<\/p>\n\n\n\n<p>Expected outcome:\n&#8211; Skaffold detects the change\n&#8211; Image rebuild + redeploy happens automatically\n&#8211; The next curl returns updated output<\/p>\n\n\n\n<p>Verify:<\/p>\n\n\n\n<pre><code class=\"language-bash\">curl http:\/\/localhost:8080\/\n<\/code><\/pre>\n\n\n\n<p>Expected outcome:<\/p>\n\n\n\n<pre><code class=\"language-text\">Hello from Kubernetes, Cloud Code for IntelliJ!\n<\/code><\/pre>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Validation<\/h3>\n\n\n\n<p>Use these checks to confirm everything is working:<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>\n<p>Kubernetes resources exist:\n   <code>bash\n   kubectl get deploy hello\n   kubectl get pods -l app=hello\n   kubectl get svc hello<\/code><\/p>\n<\/li>\n<li>\n<p>Pod is healthy:\n   <code>bash\n   kubectl describe pod -l app=hello<\/code><\/p>\n<\/li>\n<li>\n<p>Logs show requests:\n   <code>bash\n   kubectl logs -l app=hello --tail=50<\/code><\/p>\n<\/li>\n<li>\n<p>Endpoint responds:\n   <code>bash\n   curl http:\/\/localhost:8080\/<\/code><\/p>\n<\/li>\n<\/ol>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Troubleshooting<\/h3>\n\n\n\n<p>Common issues and fixes:<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Issue: <code>kubectl<\/code> points to the wrong cluster<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Symptom: resources don\u2019t appear where you expect.<\/li>\n<li>Fix:\n  <code>bash\n  kubectl config get-contexts\n  kubectl config use-context minikube<\/code><\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Issue: Docker daemon not running<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Symptom: Skaffold build fails with Docker connection errors.<\/li>\n<li>Fix: start Docker Desktop \/ Docker Engine and re-run <code>skaffold dev<\/code>.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Issue: Image pull errors in Kubernetes<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Symptom: Pod stuck in <code>ImagePullBackOff<\/code>.<\/li>\n<li>Cause: Your cluster can\u2019t access the built image.<\/li>\n<li>Fix: For Minikube, ensure Docker builds occur in an environment Minikube can see. One approach is to point your shell at Minikube\u2019s Docker daemon:\n  <code>bash\n  eval $(minikube docker-env)<\/code>\n  Then rerun:\n  <code>bash\n  skaffold dev<\/code>\n  (Exact approach depends on your OS and Minikube driver; verify Minikube docs.)<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Issue: Port-forward fails because port is in use<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Symptom: \u201cunable to listen on port 8080\u201d.<\/li>\n<li>Fix: Change <code>localPort<\/code> in <code>skaffold.yaml<\/code> to a free port (for example 18080), then curl that port.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Issue: Plugin UI doesn\u2019t match instructions<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Symptom: You can\u2019t find the exact Cloud Code menu.<\/li>\n<li>Fix: Use the CLI fallback (<code>skaffold dev<\/code>) and still benefit from Cloud Code YAML assistance and IDE context. Also verify plugin docs for your version: https:\/\/cloud.google.com\/code\/docs\/intellij<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h3 class=\"wp-block-heading\">Cleanup<\/h3>\n\n\n\n<p>Stop the dev loop:\n&#8211; If running in CLI: press <code>Ctrl+C<\/code> in the terminal running Skaffold.\n&#8211; If running in IntelliJ: click the stop button in the Run tool window.<\/p>\n\n\n\n<p>Delete Kubernetes resources (optional if Skaffold already cleaned them up, but safe to run):<\/p>\n\n\n\n<pre><code class=\"language-bash\">kubectl delete service hello --ignore-not-found=true\nkubectl delete deployment hello --ignore-not-found=true\n<\/code><\/pre>\n\n\n\n<p>Stop Minikube (optional):<\/p>\n\n\n\n<pre><code class=\"language-bash\">minikube stop\n<\/code><\/pre>\n\n\n\n<p>If you want to remove the cluster entirely:<\/p>\n\n\n\n<pre><code class=\"language-bash\">minikube delete\n<\/code><\/pre>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">11. Best Practices<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Architecture best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Keep your <strong>runtime definitions in repo<\/strong>: Kubernetes manifests, <code>skaffold.yaml<\/code>, Dockerfiles.<\/li>\n<li>Use <strong>Skaffold profiles<\/strong> for environment-specific settings rather than copying files:<\/li>\n<li>Local profile (Minikube\/kind)<\/li>\n<li>Remote profile (GKE + Artifact Registry)<\/li>\n<li>Keep a clear separation between:<\/li>\n<li>\u201cinner loop\u201d developer speed<\/li>\n<li>\u201couter loop\u201d CI\/CD governance and promotion<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">IAM\/security best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Prefer group-based IAM assignments and <strong>least privilege<\/strong>:<\/li>\n<li>Separate permissions for viewing clusters vs deploying to them.<\/li>\n<li>Use Kubernetes RBAC to restrict namespaces.<\/li>\n<li>Avoid using \u201cproject Owner\u201d for development access.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Cost best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Prefer <strong>local clusters<\/strong> whenever possible.<\/li>\n<li>Avoid provisioning cloud load balancers for development tests; use port-forward or shared ingress.<\/li>\n<li>Use Artifact Registry cleanup policies (verify current capabilities) and delete unused repos\/images.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Performance best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Optimize container builds:<\/li>\n<li>Use small base images and reduce layers.<\/li>\n<li>Cache dependencies effectively.<\/li>\n<li>Reduce redeploy time:<\/li>\n<li>Use Skaffold\u2019s sync features when applicable (verify for your language\/framework).<\/li>\n<li>Avoid rebuilding large images on every small code change.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Reliability best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Treat manifests as production-grade:<\/li>\n<li>Use readiness and liveness probes<\/li>\n<li>Set resource requests\/limits<\/li>\n<li>Validate changes in a staging-like cluster before production promotion.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Operations best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Standardize naming:<\/li>\n<li>Kubernetes labels (<code>app<\/code>, <code>component<\/code>, <code>env<\/code>, <code>team<\/code>)<\/li>\n<li>Namespaces per environment\/team<\/li>\n<li>Keep logs structured (JSON where practical) to reduce troubleshooting time.<\/li>\n<li>Add basic health endpoints early.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Governance\/tagging\/naming best practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Align with organizational policies:<\/li>\n<li>Artifact Registry repository naming conventions<\/li>\n<li>GKE cluster naming and location standards<\/li>\n<li>Use consistent label and annotation schemes for cost allocation and ownership.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">12. Security Considerations<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Identity and access model<\/h3>\n\n\n\n<p>Cloud Code for IntelliJ actions typically run as the <strong>developer\u2019s identity<\/strong>:\n&#8211; Google Cloud access via <code>gcloud<\/code> credentials and IAM\n&#8211; Kubernetes access via kubeconfig and Kubernetes RBAC<\/p>\n\n\n\n<p>Security implications:\n&#8211; A developer who can deploy to a cluster can potentially run arbitrary containers in their permitted namespaces.\n&#8211; Strong RBAC and policy enforcement are critical on shared clusters.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Encryption<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>In transit:<\/li>\n<li>Kubernetes API uses TLS<\/li>\n<li>Artifact Registry endpoints use TLS<\/li>\n<li>At rest:<\/li>\n<li>Artifact Registry and most Google Cloud services encrypt at rest by default (verify service-specific encryption docs if you have CMEK requirements).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Network exposure<\/h3>\n\n\n\n<p>Common risks:\n&#8211; Exposing dev services with public load balancers unintentionally.\n&#8211; Allowing broad network egress from workloads.<\/p>\n\n\n\n<p>Recommendations:\n&#8211; Use port-forward for local testing.\n&#8211; Use private clusters and controlled ingress for shared environments.\n&#8211; Apply NetworkPolicies (GKE Dataplane V2 \/ network policy options vary; verify for your cluster mode).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Secrets handling<\/h3>\n\n\n\n<p>Do not store secrets in:\n&#8211; Git repos\n&#8211; Kubernetes ConfigMaps\n&#8211; IDE run configurations<\/p>\n\n\n\n<p>Use:\n&#8211; Secret Manager (Google Cloud) for managed secrets (verify integration patterns)\n&#8211; Kubernetes Secrets with appropriate encryption and RBAC, or external secret operators (verify your platform standard)<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Audit\/logging<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Use Google Cloud audit logs for:<\/li>\n<li>GKE API usage<\/li>\n<li>Artifact Registry access<\/li>\n<li>Cloud Build operations<\/li>\n<li>Use Kubernetes audit logs where appropriate (availability depends on cluster configuration; verify GKE audit logging features).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Compliance considerations<\/h3>\n\n\n\n<p>Cloud Code is a developer tool, but it can affect compliance because it influences:\n&#8211; Who can deploy what, where\n&#8211; How artifacts are built and stored\n&#8211; How changes are reviewed and promoted<\/p>\n\n\n\n<p>For regulated environments:\n&#8211; Ensure production deploys go through CI\/CD with approvals.\n&#8211; Use policy controls (for example, org policy constraints, Binary Authorization where applicable\u2014verify current product fit for your environment).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Common security mistakes<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Using broad IAM roles (Owner\/Editor) for convenience<\/li>\n<li>Sharing kubeconfig files or long-lived credentials<\/li>\n<li>Deploying to production clusters from developer laptops<\/li>\n<li>Allowing unrestricted image sources (pulling from public registries without scanning)<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Secure deployment recommendations<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Use Artifact Registry with restricted write access.<\/li>\n<li>Enforce image provenance\/scanning in CI.<\/li>\n<li>Use separate projects\/clusters for dev\/staging\/prod.<\/li>\n<li>Use namespaces + RBAC + quotas to isolate teams.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">13. Limitations and Gotchas<\/h2>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>It\u2019s an IDE plugin, not a managed service<\/strong>: reliability depends on local machine setup (Docker, kubectl, Skaffold versions).<\/li>\n<li><strong>Version compatibility<\/strong>: IntelliJ versions, plugin versions, and tool versions can drift. Pin versions where practical and document the supported stack.<\/li>\n<li><strong>Kubernetes context mistakes<\/strong>: It\u2019s easy to deploy to the wrong cluster\/namespace if contexts are not managed carefully.<\/li>\n<li><strong>Remote cluster iteration is slower and costlier<\/strong>: Latency and paid resources can make dev loops painful on shared clusters.<\/li>\n<li><strong>GKE authentication requirements<\/strong>: Accessing GKE commonly requires the correct auth plugin and kubeconfig setup. If cluster credentials expire or plugins mismatch, you\u2019ll see confusing errors.<\/li>\n<li><strong>Skaffold config API versions<\/strong>: Skaffold periodically changes config schema versions; use <code>skaffold fix<\/code> to migrate and validate.<\/li>\n<li><strong>Windows\/WSL nuances<\/strong>: Docker and filesystem event propagation can affect rebuild triggers and performance. Verify recommended setups for your OS and IDE.<\/li>\n<li><strong>Observability cost surprises<\/strong>: Logging everything at debug level in shared environments can increase logging ingestion costs.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">14. Comparison with Alternatives<\/h2>\n\n\n\n<p>Cloud Code for IntelliJ is one option in a broader ecosystem of cloud developer tools.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Key alternatives<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Cloud Code for VS Code<\/strong> (Google Cloud): Similar intent, different IDE ecosystem.<\/li>\n<li><strong>Cloud Shell Editor \/ Cloud-based development environments<\/strong>: Shift tooling to the cloud; may reduce workstation setup burden (verify current Google Cloud offerings and Cloud Code support).<\/li>\n<li><strong>JetBrains Kubernetes plugin + manual Skaffold<\/strong>: Use IDE Kubernetes features without Google\u2019s Cloud Code layer.<\/li>\n<li><strong>Pure CLI workflow<\/strong>: <code>skaffold<\/code>, <code>kubectl<\/code>, <code>helm<\/code>, <code>kustomize<\/code> without IDE integration.<\/li>\n<li><strong>Other cloud IDE toolkits<\/strong>:<\/li>\n<li>AWS Toolkit for JetBrains<\/li>\n<li>Azure Toolkit for IntelliJ\/JetBrains<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Comparison table<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>Option<\/th>\n<th>Best For<\/th>\n<th>Strengths<\/th>\n<th>Weaknesses<\/th>\n<th>When to Choose<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Cloud Code for IntelliJ (Google Cloud)<\/td>\n<td>IntelliJ teams building Kubernetes apps (often for GKE)<\/td>\n<td>Skaffold-centric inner loop; Kubernetes-focused; integrates with Google Cloud workflows<\/td>\n<td>Depends on local setup; plugin\/UI can change; primarily Kubernetes-oriented<\/td>\n<td>You want IntelliJ + Kubernetes + repeatable Skaffold-based loops<\/td>\n<\/tr>\n<tr>\n<td>Cloud Code for VS Code (Google Cloud)<\/td>\n<td>VS Code teams<\/td>\n<td>Similar workflows in VS Code ecosystem<\/td>\n<td>Not IntelliJ; different IDE experience<\/td>\n<td>Your org standardizes on VS Code<\/td>\n<\/tr>\n<tr>\n<td>JetBrains Kubernetes plugin + CLI tools<\/td>\n<td>Teams wanting minimal Google-specific tooling<\/td>\n<td>Strong IDE support; flexible<\/td>\n<td>Less \u201cguided\u201d Google Cloud path; you own the workflow glue<\/td>\n<td>You already have a mature Kubernetes toolchain<\/td>\n<\/tr>\n<tr>\n<td>Skaffold + kubectl only (no IDE integration)<\/td>\n<td>Terminal-first engineers<\/td>\n<td>Most portable; easy to automate<\/td>\n<td>More context switching; steeper learning curve<\/td>\n<td>You prioritize tool portability over IDE features<\/td>\n<\/tr>\n<tr>\n<td>Cloud-based dev environments (verify current offerings)<\/td>\n<td>Regulated environments or standardized dev machines<\/td>\n<td>Consistent tooling; reduced workstation variance<\/td>\n<td>Requires platform investment; may affect performance\/latency<\/td>\n<td>You want centrally managed dev environments<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">15. Real-World Example<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Enterprise example (platform + compliance)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> A financial services company has hundreds of microservices on GKE. Developers use inconsistent scripts, and security requires auditable, least-privilege access.<\/li>\n<li><strong>Proposed architecture:<\/strong><\/li>\n<li>Standard repo templates include <code>skaffold.yaml<\/code>, Kubernetes manifests, and policy-checked defaults.<\/li>\n<li>Dev clusters per business unit; staging shared; production locked behind CI\/CD approvals.<\/li>\n<li>Artifact Registry for images; Cloud Build for reproducible builds; centralized logging\/monitoring.<\/li>\n<li><strong>Why Cloud Code for IntelliJ was chosen:<\/strong><\/li>\n<li>Many teams use IntelliJ.<\/li>\n<li>Cloud Code aligns developer workflows to Skaffold and Kubernetes manifests, reducing drift.<\/li>\n<li>Integrates cleanly with IAM and existing RBAC controls.<\/li>\n<li><strong>Expected outcomes:<\/strong><\/li>\n<li>Faster onboarding and fewer environment-specific scripts<\/li>\n<li>More consistent build\/deploy processes<\/li>\n<li>Easier audits due to standardized configs and controlled access<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Startup\/small-team example (speed + simplicity)<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Problem:<\/strong> A startup runs a few services on GKE and wants faster iteration without building a full internal platform.<\/li>\n<li><strong>Proposed architecture:<\/strong><\/li>\n<li>Local dev via Minikube + Cloud Code + Skaffold<\/li>\n<li>One shared staging cluster on GKE<\/li>\n<li>Artifact Registry for images<\/li>\n<li><strong>Why Cloud Code for IntelliJ was chosen:<\/strong><\/li>\n<li>Developers already use IntelliJ.<\/li>\n<li>Quick inner-loop wins without adopting a heavy platform toolchain.<\/li>\n<li><strong>Expected outcomes:<\/strong><\/li>\n<li>Shorter feedback loops<\/li>\n<li>Less time spent on Kubernetes command sequences<\/li>\n<li>A smoother path to production-like deployment patterns<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">16. FAQ<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">1) Is Cloud Code for IntelliJ a managed Google Cloud service?<\/h3>\n\n\n\n<p>No. Cloud Code for IntelliJ is an IDE plugin installed locally. Any cloud costs come from the Google Cloud services you use (GKE, Artifact Registry, Cloud Build, etc.).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">2) Do I need a Google Cloud project to use Cloud Code for IntelliJ?<\/h3>\n\n\n\n<p>Not strictly for local-only Kubernetes development, but you typically need a project for real Google Cloud workflows (GKE clusters, Artifact Registry, IAM policies).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">3) What is the main tool Cloud Code uses under the hood?<\/h3>\n\n\n\n<p>Cloud Code commonly relies on <strong>Skaffold<\/strong> for build\/deploy dev loops and on <strong>kubectl<\/strong> for Kubernetes interaction.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">4) Can I use Cloud Code for IntelliJ with a local Kubernetes cluster?<\/h3>\n\n\n\n<p>Yes. Local clusters like Minikube or kind are common for low-cost inner-loop development. You select the target via your kubeconfig context.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">5) Can I use it with GKE?<\/h3>\n\n\n\n<p>Yes, as long as your kubeconfig is configured for the GKE cluster and your identity has appropriate IAM and Kubernetes RBAC permissions.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">6) Does Cloud Code for IntelliJ deploy to production?<\/h3>\n\n\n\n<p>It can deploy to any cluster you have access to, but production deployments should typically be done via CI\/CD with approvals, policy checks, and audit controls.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">7) Does Cloud Code for IntelliJ support debugging in Kubernetes?<\/h3>\n\n\n\n<p>Cloud Code is designed to help with Kubernetes development and troubleshooting, and may support debugging workflows depending on language\/runtime and configuration. Verify current debugging support for your stack in the official docs: https:\/\/cloud.google.com\/code\/docs\/intellij<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">8) Is Cloud Code for IntelliJ only for Kubernetes?<\/h3>\n\n\n\n<p>Cloud Code is primarily Kubernetes-centric. If your workloads are not containerized or not running on Kubernetes, the value may be limited.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">9) Do I have to use Docker?<\/h3>\n\n\n\n<p>Many Skaffold workflows use Docker, but Skaffold supports multiple builders. Your actual setup depends on your chosen build configuration and platform. Verify supported builders in Skaffold docs.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">10) How do I avoid deploying to the wrong cluster?<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Name contexts clearly<\/li>\n<li>Use separate kubeconfig files per environment when needed<\/li>\n<li>Add strong RBAC boundaries between dev\/staging\/prod<\/li>\n<li>Consider policy controls that prevent dev identities from accessing production clusters<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">11) What are the biggest cost risks when using Cloud Code with GKE?<\/h3>\n\n\n\n<p>Leaving clusters running, accidentally creating load balancers, generating large volumes of logs, and frequently pushing large images to a registry.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">12) Is Artifact Registry required?<\/h3>\n\n\n\n<p>Not for local-only development. For GKE deployments, a registry like Artifact Registry is the standard place to push images.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">13) Can my CI pipeline reuse my <code>skaffold.yaml<\/code>?<\/h3>\n\n\n\n<p>Often yes, at least partially. Many teams align local and CI workflows around the same Skaffold config, with profiles for CI vs local. Validate carefully to avoid environment-specific assumptions.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">14) What\u2019s the difference between Cloud Code and Cloud Build?<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Cloud Code: IDE plugin to help developers run workflows.<\/li>\n<li>Cloud Build: managed Google Cloud service to execute builds in the cloud.\nThey can be used together when Skaffold is configured to build using Cloud Build.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">15) Where should I look for the most accurate, up-to-date feature list?<\/h3>\n\n\n\n<p>The official Cloud Code for IntelliJ documentation: https:\/\/cloud.google.com\/code\/docs\/intellij and the plugin release notes in JetBrains Marketplace (verify the current listing for your IDE version).<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">17. Top Online Resources to Learn Cloud Code for IntelliJ<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>Resource Type<\/th>\n<th>Name<\/th>\n<th>Why It Is Useful<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Official documentation<\/td>\n<td>Cloud Code for IntelliJ docs \u2014 https:\/\/cloud.google.com\/code\/docs\/intellij<\/td>\n<td>Primary source for supported features, setup, and workflows<\/td>\n<\/tr>\n<tr>\n<td>Official SDK docs<\/td>\n<td>Google Cloud CLI install \u2014 https:\/\/cloud.google.com\/sdk\/docs\/install<\/td>\n<td>Required for authenticating and interacting with Google Cloud projects<\/td>\n<\/tr>\n<tr>\n<td>Official Kubernetes docs<\/td>\n<td>kubectl install \u2014 https:\/\/kubernetes.io\/docs\/tasks\/tools\/<\/td>\n<td>Ensures your Kubernetes CLI is correctly installed<\/td>\n<\/tr>\n<tr>\n<td>Official tool docs<\/td>\n<td>Skaffold documentation \u2014 https:\/\/skaffold.dev\/docs\/<\/td>\n<td>Cloud Code workflows commonly rely on Skaffold<\/td>\n<\/tr>\n<tr>\n<td>Official pricing<\/td>\n<td>Google Cloud Pricing \u2014 https:\/\/cloud.google.com\/pricing<\/td>\n<td>Understand how underlying services are billed<\/td>\n<\/tr>\n<tr>\n<td>Official calculator<\/td>\n<td>Pricing Calculator \u2014 https:\/\/cloud.google.com\/products\/calculator<\/td>\n<td>Build a region- and usage-specific cost estimate<\/td>\n<\/tr>\n<tr>\n<td>Official service docs<\/td>\n<td>GKE documentation \u2014 https:\/\/cloud.google.com\/kubernetes-engine\/docs<\/td>\n<td>Production target for many Cloud Code users<\/td>\n<\/tr>\n<tr>\n<td>Official service docs<\/td>\n<td>Artifact Registry documentation \u2014 https:\/\/cloud.google.com\/artifact-registry\/docs<\/td>\n<td>Recommended container image registry for Google Cloud<\/td>\n<\/tr>\n<tr>\n<td>Official service docs<\/td>\n<td>Cloud Build documentation \u2014 https:\/\/cloud.google.com\/build\/docs<\/td>\n<td>Common CI build service used with container workflows<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">18. Training and Certification Providers<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>Institute<\/th>\n<th>Suitable Audience<\/th>\n<th>Likely Learning Focus<\/th>\n<th>Mode<\/th>\n<th>Website URL<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>DevOpsSchool.com<\/td>\n<td>DevOps engineers, SREs, developers<\/td>\n<td>DevOps tooling, Kubernetes, CI\/CD, cloud fundamentals<\/td>\n<td>Check website<\/td>\n<td>https:\/\/www.devopsschool.com\/<\/td>\n<\/tr>\n<tr>\n<td>ScmGalaxy.com<\/td>\n<td>Beginners to intermediate engineers<\/td>\n<td>SCM, DevOps practices, tooling labs<\/td>\n<td>Check website<\/td>\n<td>https:\/\/www.scmgalaxy.com\/<\/td>\n<\/tr>\n<tr>\n<td>CLoudOpsNow.in<\/td>\n<td>Cloud\/operations teams<\/td>\n<td>Cloud ops, automation, operational readiness<\/td>\n<td>Check website<\/td>\n<td>https:\/\/www.cloudopsnow.in\/<\/td>\n<\/tr>\n<tr>\n<td>SreSchool.com<\/td>\n<td>SREs, platform engineers<\/td>\n<td>Reliability engineering, monitoring, incident response<\/td>\n<td>Check website<\/td>\n<td>https:\/\/www.sreschool.com\/<\/td>\n<\/tr>\n<tr>\n<td>AiOpsSchool.com<\/td>\n<td>Ops and engineering teams<\/td>\n<td>AIOps concepts, observability, automation<\/td>\n<td>Check website<\/td>\n<td>https:\/\/www.aiopsschool.com\/<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">19. Top Trainers<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>Platform\/Site<\/th>\n<th>Likely Specialization<\/th>\n<th>Suitable Audience<\/th>\n<th>Website URL<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>RajeshKumar.xyz<\/td>\n<td>DevOps\/Kubernetes\/cloud training content (verify current offerings)<\/td>\n<td>Beginners to advanced<\/td>\n<td>https:\/\/rajeshkumar.xyz\/<\/td>\n<\/tr>\n<tr>\n<td>devopstrainer.in<\/td>\n<td>DevOps and automation training platform (verify current offerings)<\/td>\n<td>DevOps engineers, developers<\/td>\n<td>https:\/\/www.devopstrainer.in\/<\/td>\n<\/tr>\n<tr>\n<td>devopsfreelancer.com<\/td>\n<td>Freelance DevOps help\/training resources (verify current offerings)<\/td>\n<td>Small teams, startups<\/td>\n<td>https:\/\/www.devopsfreelancer.com\/<\/td>\n<\/tr>\n<tr>\n<td>devopssupport.in<\/td>\n<td>DevOps support\/training resources (verify current offerings)<\/td>\n<td>Ops teams and engineers<\/td>\n<td>https:\/\/www.devopssupport.in\/<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">20. Top Consulting Companies<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>Company Name<\/th>\n<th>Likely Service Area<\/th>\n<th>Where They May Help<\/th>\n<th>Consulting Use Case Examples<\/th>\n<th>Website URL<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>cotocus.com<\/td>\n<td>Cloud\/DevOps consulting (verify exact services)<\/td>\n<td>Architecture, DevOps implementation, ops support<\/td>\n<td>Kubernetes platform setup, CI\/CD design, cloud migration planning<\/td>\n<td>https:\/\/cotocus.com\/<\/td>\n<\/tr>\n<tr>\n<td>DevOpsSchool.com<\/td>\n<td>DevOps consulting and training (verify exact services)<\/td>\n<td>DevOps transformations, tooling, enablement<\/td>\n<td>Standardizing developer workflows, Kubernetes adoption programs<\/td>\n<td>https:\/\/www.devopsschool.com\/<\/td>\n<\/tr>\n<tr>\n<td>DEVOPSCONSULTING.IN<\/td>\n<td>DevOps consulting (verify exact services)<\/td>\n<td>Implementation and advisory<\/td>\n<td>Pipeline automation, containerization strategy, operational readiness<\/td>\n<td>https:\/\/www.devopsconsulting.in\/<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">21. Career and Learning Roadmap<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">What to learn before Cloud Code for IntelliJ<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Container basics: images, Dockerfile, registries<\/li>\n<li>Kubernetes fundamentals: Pods, Deployments, Services, Ingress, ConfigMaps\/Secrets<\/li>\n<li>kubectl basics and kubeconfig contexts<\/li>\n<li>Basic Google Cloud concepts: projects, IAM, APIs<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">What to learn after Cloud Code for IntelliJ<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>GKE operations: cluster modes, node pools, upgrades, autoscaling<\/li>\n<li>Artifact Registry management and IAM hardening<\/li>\n<li>CI\/CD for Kubernetes (Cloud Build, GitHub Actions, GitLab CI, etc.)<\/li>\n<li>Policy and governance:<\/li>\n<li>Admission controls and policy-as-code (verify what your org uses)<\/li>\n<li>Image scanning and provenance controls<\/li>\n<li>Observability:<\/li>\n<li>Cloud Logging\/Monitoring dashboards and alerting<\/li>\n<li>SLOs and error budgets (SRE practices)<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Job roles that use it<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Cloud engineers building on Kubernetes<\/li>\n<li>Platform engineers providing developer tooling<\/li>\n<li>DevOps engineers standardizing deployment workflows<\/li>\n<li>SREs supporting dev\/staging cluster operations<\/li>\n<li>Application developers working on containerized services<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Certification path (if available)<\/h3>\n\n\n\n<p>Cloud Code itself is not typically a certification topic, but it supports skills used in Google Cloud certifications. Consider (verify current certification catalog):\n&#8211; Associate Cloud Engineer\n&#8211; Professional Cloud Developer\n&#8211; Professional Cloud DevOps Engineer<\/p>\n\n\n\n<p>Official certification overview: https:\/\/cloud.google.com\/learn\/certification<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Project ideas for practice<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Add a second microservice and use Skaffold to deploy both<\/li>\n<li>Introduce environment profiles (local vs GKE)<\/li>\n<li>Add readiness\/liveness probes and resource limits<\/li>\n<li>Push images to Artifact Registry and deploy to a GKE dev namespace<\/li>\n<li>Add basic CI: build + unit tests + container build + manifest validation<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">22. Glossary<\/h2>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Artifact Registry<\/strong>: Google Cloud service for storing and managing build artifacts such as container images.<\/li>\n<li><strong>Cloud Build<\/strong>: Google Cloud managed build service for running builds and CI steps.<\/li>\n<li><strong>Cloud Code for IntelliJ<\/strong>: Google Cloud IDE plugin for IntelliJ-based IDEs focusing on Kubernetes\/cloud-native development workflows.<\/li>\n<li><strong>Context (kubeconfig context)<\/strong>: Named cluster\/user\/namespace combination used by <code>kubectl<\/code> to decide where commands are executed.<\/li>\n<li><strong>GKE (Google Kubernetes Engine)<\/strong>: Managed Kubernetes service on Google Cloud.<\/li>\n<li><strong>IAM (Identity and Access Management)<\/strong>: Google Cloud authorization system controlling who can do what on which resources.<\/li>\n<li><strong>Inner loop<\/strong>: Fast developer cycle of edit \u2192 build \u2192 deploy \u2192 test.<\/li>\n<li><strong>Kubernetes manifests<\/strong>: YAML files declaring desired state for Kubernetes resources (Deployments, Services, etc.).<\/li>\n<li><strong>kubectl<\/strong>: CLI for interacting with the Kubernetes API.<\/li>\n<li><strong>Minikube<\/strong>: Tool for running a local Kubernetes cluster.<\/li>\n<li><strong>Namespace<\/strong>: Kubernetes mechanism for isolating resources within a cluster.<\/li>\n<li><strong>Port-forward<\/strong>: Technique to forward a local port to a Kubernetes pod or service for testing without external exposure.<\/li>\n<li><strong>RBAC (Role-Based Access Control)<\/strong>: Kubernetes authorization mechanism controlling actions within the cluster.<\/li>\n<li><strong>Skaffold<\/strong>: Tool that automates building, pushing, and deploying applications to Kubernetes during development.<\/li>\n<li><strong>Workload<\/strong>: A running application component in Kubernetes (for example, a Deployment managing pods).<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">23. Summary<\/h2>\n\n\n\n<p>Cloud Code for IntelliJ (Google Cloud, Application development) is an IDE plugin that brings Kubernetes-focused development workflows into IntelliJ. It typically works by orchestrating standard tools like Skaffold and kubectl so developers can build, deploy, and iterate on containerized applications more quickly and consistently.<\/p>\n\n\n\n<p>It matters because it reduces the friction of Kubernetes development while reinforcing repo-based, repeatable configurations that can align with CI\/CD and production patterns. Cloud Code itself usually has no direct cost, but the workflows can create costs in GKE, Artifact Registry, Cloud Build, logging, and networking\u2014so use local clusters and avoid unnecessary cloud resources during development.<\/p>\n\n\n\n<p>Use Cloud Code for IntelliJ when your team builds Kubernetes workloads (often targeting GKE) and wants a standardized, IDE-first developer loop. For the next learning step, deepen your Skaffold and Kubernetes knowledge and then map your local workflow to GKE with Artifact Registry and CI\/CD using official docs:\n&#8211; Cloud Code for IntelliJ: https:\/\/cloud.google.com\/code\/docs\/intellij\n&#8211; Skaffold: https:\/\/skaffold.dev\/docs\/\n&#8211; GKE: https:\/\/cloud.google.com\/kubernetes-engine\/docs<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Application development<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[54,51],"tags":[],"class_list":["post-594","post","type-post","status-publish","format-standard","hentry","category-application-development","category-google-cloud"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/594","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/comments?post=594"}],"version-history":[{"count":0,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/594\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/media?parent=594"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/categories?post=594"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/tags?post=594"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}