75+ Kong Interview Questions: Hands-On Config

79 hands-on Kong Gateway interview questions: Admin API, routes, plugin config, decK, Kong Ingress Controller YAML, Lua plugins and troubleshooting.

Oct 1, 2025 - 10:51
Nov 6, 2026 - 05:03
 0  279
75+ Kong Interview Questions: Hands-On Config

Kong interview questions for hands-on roles test whether you can run Kong Gateway and configure it: Admin API calls, Service and Route fields, plugin settings for auth, rate limiting, caching and CORS, decK commands, Kong Ingress Controller manifests and Lua custom plugins. This page has 79 practical questions with checked answers, grouped by experience.

This is the hands-on companion to our Kong API Gateway interview questions, which covers architecture, deployment topologies, hybrid mode and Konnect. Here the focus is on commands, config fields and YAML you are likely to be asked to write. Answers were checked against the Kong Gateway documentation in November 2026.

Key takeaways

  • Know the Admin API by heart: create a Service, a Route, a Consumer and a plugin with curl, and know PATCH vs PUT.
  • Route behaviour questions focus on strip_path, preserve_host, regex paths with ~ and regex_priority.
  • Experienced candidates should write plugin config for rate-limiting, key-auth, JWT, CORS, proxy-cache and request-size-limiting from memory.
  • decK (gateway diff, gateway sync, --select-tag) and KIC resources (KongPlugin, KongConsumer, annotations) are standard in 2 to 5 year interviews.
  • Senior roles add Lua custom plugins, PDK functions, plugin priority and node operations like drain, reload and migrations.

How to use this guide

Your levelRead firstPractise
FresherQuestions 1 to 26Run Kong in Docker and build a Service, Route and key-auth Consumer with curl
2 to 5 yearsQuestions 27 to 56Manage the same config with decK in Git, then deploy it with KIC on a kind cluster
SeniorQuestions 57 to 68Write and test a small Lua plugin with Pongo
EveryoneQuestions 69 to 79Reproduce each scenario in a lab and fix it

Kong interview questions for freshers

Questions 1 to 26 are hands-on basics: running Kong, the Admin API, Services, Routes, Consumers and declarative files.

1. How do you check that a Kong node is up and see its configuration?

Call the Admin API root: curl -s http://localhost:8001/ returns node information, including the version, enabled plugins and the loaded configuration. GET /status returns database reachability and connection counts. From the shell, kong health checks that the node's services are running.

2. Where does Kong read its configuration from, and how do environment variables override it?

Kong reads kong.conf (commonly /etc/kong/kong.conf, or a file passed with -c). Any property can be set as an environment variable by upper-casing it and adding KONG_, so pg_host becomes KONG_PG_HOST. Containers almost always use environment variables.

3. Which values can the database property take?

postgres (the default) or off for DB-less mode. Cassandra support was removed in Kong Gateway 3.0, so older answers that mention it are out of date.

4. What are the default listen addresses you should know?

PropertyDefaultPurpose
proxy_listen0.0.0.0:8000, 0.0.0.0:8443 (ssl)Client traffic
admin_listen127.0.0.1:8001, 127.0.0.1:8444 (ssl)Admin API
status_listen127.0.0.1:8007Status and readiness API
cluster_listen0.0.0.0:8005Control plane for hybrid data planes

Values are from the Kong configuration reference. The Admin API binds to localhost by default for a reason: do not expose it.

5. Which commands prepare a new Postgres database for Kong?

kong migrations bootstrap creates the schema on an empty database. After an upgrade you run kong migrations up and, once all nodes run the new version, kong migrations finish. kong migrations list shows what has run, and kong migrations reset deletes everything, so never run it on production by mistake.

6. What is the difference between kong stop, kong quit and kong reload?

kong stop stops the node immediately. kong quit shuts it down gracefully, letting in-flight requests finish. kong reload applies changes to kong.conf without dropping connections by starting new NGINX workers. kong restart is a stop followed by a start.

7. What do kong check and kong prepare do?

kong check validates a configuration file and reports errors without starting anything. kong prepare builds the prefix directory (generated nginx.conf and related files) without starting Kong, which is useful when you want NGINX to be started by another process or want to inspect the generated config.

8. How do you create a Gateway Service with the Admin API?

curl -i -X POST http://localhost:8001/services \
  --data name=orders \
  --data url=http://orders.internal:8080

The url field is shorthand that sets protocol, host, port and path at once. It is write-only, so a later GET shows the separate fields instead.

9. What timeouts and retries does a Service have by default?

connect_timeout, read_timeout and write_timeout each default to 60000 ms, and retries defaults to 5. Kong retries idempotent methods (GET, HEAD, PUT, DELETE, OPTIONS, TRACE) on failure; POST and PATCH are not retried by default. Lower the timeouts for fast internal APIs so failures surface quickly.

10. How do you add a Route to a Service?

curl -i -X POST http://localhost:8001/services/orders/routes \
  --data name=orders-v1 \
  --data 'paths[]=/api/orders' \
  --data 'methods[]=GET' \
  --data 'methods[]=POST'

Test it through the proxy port: curl -i http://localhost:8000/api/orders.

11. Which fields can a Route match on?

For HTTP: paths, hosts, methods and headers. For stream (TCP/TLS/UDP) routes: snis, sources and destinations. protocols limits which protocols the Route accepts. A request must satisfy every field that is set on the Route.

12. What does strip_path do?

With strip_path set to true (the default), Kong removes the matched path prefix before sending the request upstream. A Route on /api/orders forwards /api/orders/42 as /42 (plus any Service path). Set it to false if the backend expects the full path.

13. What does preserve_host do?

By default (preserve_host false) Kong sets the upstream Host header to the Service's host. With true, Kong passes the client's original Host header through. Backends that serve several virtual hosts, or that build absolute URLs from the Host header, usually need true.

14. How do you write a regex path in a Route?

Prefix the path with ~, for example ~/users/\d+$. Without the tilde, Kong treats the value as a plain prefix. Regex routes can be ordered with regex_priority (higher is evaluated first, default 0); plain prefix routes match longer paths before shorter ones.

15. How do you enable a plugin on a single Route?

curl -X POST http://localhost:8001/routes/orders-v1/plugins \
  --data name=key-auth

The same pattern works for /services/{name}/plugins and /consumers/{name}/plugins. Posting to /plugins without a scope enables it globally.

16. How do you create a Consumer and give it an API key?

curl -X POST http://localhost:8001/consumers --data username=mobile-app
curl -X POST http://localhost:8001/consumers/mobile-app/key-auth

Kong generates a key if you do not supply one. The client then sends it in the apikey header or query parameter, which is the default name in config.key_names.

17. What does hide_credentials do in authentication plugins?

When true, Kong removes the credential (header or query parameter) before proxying, so the backend never sees the API key or password. It is off by default. Turn it on unless the backend really needs the credential.

18. How can you find which plugins are available on a node and what their fields are?

GET /plugins/enabled lists plugins the node has loaded, and GET /schemas/plugins/{name} returns the schema with every config field, type and default. This is faster and more accurate for your version than searching blog posts.

19. How do you list or delete entities with the Admin API?

GET on the collection (/services, /routes, /plugins, /consumers) lists them with pagination through offset; GET on /services/{name or id} returns one. DELETE on the entity URL removes it. You cannot delete a Service that still has Routes attached; delete or move the Routes first.

20. What does PATCH do compared with PUT on the Admin API?

PATCH changes only the fields you send. PUT creates or replaces the entity at that name or ID, resetting fields you leave out to their defaults. PUT is handy for idempotent scripts; PATCH is safer for quick edits.

21. What response headers help you see Kong's latency?

X-Kong-Upstream-Latency is the time the upstream took, and X-Kong-Proxy-Latency is time spent in Kong before proxying (plugins, routing). A Via header names Kong. The headers property in kong.conf controls which of these are sent; many teams remove them at the edge.

22. How do you run Kong in Docker for local practice?

Start a Postgres container, run the kong migrations bootstrap command in a one-off Kong container with KONG_DATABASE=postgres and KONG_PG_HOST set, then start Kong publishing ports 8000, 8443 and 8001 (bind 8001 to 127.0.0.1). For DB-less, set KONG_DATABASE=off and KONG_DECLARATIVE_CONFIG to a mounted file. Docker basics are in our Docker interview questions.

23. How do you load configuration into a DB-less node at runtime?

POST the whole declarative file to /config on the Admin API, for example curl -X POST http://localhost:8001/config -F [email protected]. It replaces the full configuration in memory. Individual POST or PATCH calls on entities are rejected in DB-less mode.

24. What is the minimum declarative file for one Service and Route?

_format_version: "3.0"
services:
  - name: orders
    url: http://orders.internal:8080
    routes:
      - name: orders-v1
        paths:
          - /api/orders
    plugins:
      - name: rate-limiting
        config:
          minute: 60
          policy: local

Validate it with kong config parse kong.yaml before loading it.

25. How do you export a database-backed Kong configuration to a file?

kong config db_export kong.yaml writes the database contents as declarative config, and kong config db_import loads a file into the database. Most teams use decK for this instead, because decK can diff and sync rather than only import.

26. What do tags do on Kong entities?

Tags are free-text labels on Services, Routes, Plugins, Consumers and other entities. You can filter Admin API listings with ?tags=team-payments, and GET /tags/{tag} lists every entity with that tag. decK uses tags to give each team its own slice of configuration.

Kong interview questions for 2 to 5 years of experience

This section is about configuring bundled plugins, decK workflows, Kong Ingress Controller manifests and routing details.

27. How do you configure the rate-limiting plugin for 100 requests per minute per consumer?

plugins:
  - name: rate-limiting
    route: orders-v1
    config:
      minute: 100
      limit_by: consumer
      policy: redis
      redis:
        host: redis.internal
        port: 6379

limit_by can also be ip, credential, service, header, path or consumer-group. Check the field names with GET /schemas/plugins/rate-limiting on your version, because the Redis settings moved under a redis block in 3.x.

28. What headers does a client see from the rate-limiting plugin?

Kong adds headers such as RateLimit-Limit, RateLimit-Remaining and RateLimit-Reset, plus per-window headers like X-RateLimit-Remaining-Minute. When the limit is exceeded the client gets HTTP 429. config.hide_client_headers removes these headers if you do not want to expose limits.

29. What is the difference between rate-limiting and response-ratelimiting?

rate-limiting counts requests. response-ratelimiting lets the upstream decide what to count by returning a header (by default X-Kong-Limit, for example X-Kong-Limit: videos=1), so you can limit expensive operations differently from cheap ones on the same API.

30. How do you cap request body size?

Enable request-size-limiting and set config.allowed_payload_size (megabytes by default; size_unit can change it). Requests above the limit get HTTP 413. Set it per Route for upload endpoints rather than raising the global limit.

31. How do you cache responses in Kong?

The proxy-cache plugin caches responses in memory (strategy: memory) by status code, content type and method, with cache_ttl controlling lifetime. Kong adds an X-Cache-Status header (Miss, Hit, Bypass, Refresh) so you can check behaviour. Enterprise adds proxy-cache-advanced with Redis storage.

32. How do you add a request ID for tracing across services?

Enable correlation-id. It adds a header (default Kong-Request-ID) with a generated value such as a UUID, and can echo it back to the client with echo_downstream. Log the same header in every service so you can follow one request. For full distributed tracing use the opentelemetry plugin.

33. How do you configure CORS for a single-page app?

plugins:
  - name: cors
    route: orders-v1
    config:
      origins:
        - https://app.example.com
      methods: [GET, POST, OPTIONS]
      headers: [Authorization, Content-Type]
      credentials: true
      max_age: 3600

Do not combine credentials: true with a wildcard origin. Make sure the Route accepts the OPTIONS method or preflight requests will not reach the plugin.

34. How do you block or allow clients by IP?

Use ip-restriction with config.allow or config.deny lists of IPs or CIDRs. Behind a load balancer Kong sees the balancer's address unless you set trusted_ips and real_ip_header in kong.conf, so configure those first or the plugin will block the wrong addresses.

35. What do trusted_ips and real_ip_header control?

trusted_ips lists CIDRs whose forwarded headers Kong believes. real_ip_header (default X-Real-IP) names the header to read the client address from, and can be X-Forwarded-For or proxy_protocol. Only trust your own load balancers; trusting 0.0.0.0/0 lets clients spoof their IP.

36. How do you put an API in maintenance mode without touching the backend?

Enable request-termination on the Route or Service with status_code: 503 and a message. Kong answers every request itself. Scope it to one Consumer if you want to cut off only that client.

37. How do you add, rename or remove headers on the way to the upstream?

Use request-transformer with its add, append, replace, rename and remove blocks for headers, query strings and body fields. response-transformer does the same on the way back. Keep transformations small; complex logic belongs in a custom plugin or the service.

38. How do you send Kong access logs to an HTTP collector?

Enable http-log with config.http_endpoint pointing to the collector. Kong batches log entries in a queue and sends JSON containing request, response, latencies, Route, Service and Consumer. file-log, tcp-log, udp-log and syslog are alternatives.

39. How do you expose Prometheus metrics?

Enable the prometheus plugin (usually globally) and scrape /metrics on the Status API, not the Admin API. Options such as status_code_metrics, latency_metrics and bandwidth_metrics turn on the heavier metrics. Pair it with the Prometheus and Grafana skills in our DevOps training.

40. How do you configure the JWT plugin for a consumer?

curl -X POST http://localhost:8001/routes/orders-v1/plugins \
  --data name=jwt --data 'config.claims_to_verify=exp'
curl -X POST http://localhost:8001/consumers/mobile-app/jwt \
  --data algorithm=RS256 \
  --data key=mobile-app-issuer \
  --data-urlencode [email protected]

Kong matches the token's iss claim (by default) to the credential key and verifies the signature with that credential's secret or public key.

41. How do you use decK to see what would change before applying it?

deck gateway diff kong.yaml compares the file with the running gateway and prints creates, updates and deletes. deck gateway sync kong.yaml applies the differences. Run diff in the pull request and sync after merge.

42. Which decK commands are used most often?

CommandWhat it does
deck gateway pingChecks connectivity to the Admin API
deck gateway dumpExports the running config to a file
deck gateway validateValidates a file against the gateway
deck gateway diffShows planned changes
deck gateway syncApplies the file
deck file openapi2kongGenerates Kong config from an OpenAPI spec
deck file mergeCombines several files into one

See the decK documentation for the full command list.

43. How does --select-tag change what decK syncs?

With --select-tag team-orders, decK only reads, diffs and syncs entities with that tag, and adds the tag to entities it creates. Entities without the tag are left alone, so several teams can manage one gateway safely as long as each always uses its own tag.

44. How do you keep secrets out of a decK file?

decK substitutes environment variables named DECK_* in the file, for example ${{ env "DECK_REDIS_PASSWORD" }}, and Kong itself supports vault references such as {vault://env/redis-password} in referenceable fields. Keep the file in Git and the values in your CI secret store or a vault.

45. How do you generate Kong configuration from an OpenAPI spec?

deck file openapi2kong -s openapi.yaml -o kong.yaml converts paths and servers into Services and Routes. You then add plugins and tags with other decK file steps or by merging a plugins file, and finish with deck gateway diff. This is the core of an APIOps pipeline, similar to the GitLab flows in our GitLab CI/CD interview questions.

46. How do you install Kong Ingress Controller on Kubernetes?

The supported way is the Kong Helm chart (kong/ingress for KIC with a gateway, or kong/kong). After install, an IngressClass named kong exists and KIC watches Ingress, Gateway API and Kong CRDs. Kubernetes basics for this are covered in our Kubernetes scenario questions.

47. What does a minimal Ingress for Kong look like?

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: orders
  annotations:
    konghq.com/strip-path: "true"
    konghq.com/plugins: orders-rate-limit
spec:
  ingressClassName: kong
  rules:
    - http:
        paths:
          - path: /api/orders
            pathType: Prefix
            backend:
              service:
                name: orders
                port:
                  number: 8080

48. How do you define a plugin as a Kubernetes resource?

apiVersion: configuration.konghq.com/v1
kind: KongPlugin
metadata:
  name: orders-rate-limit
plugin: rate-limiting
config:
  minute: 100
  policy: local

Attach it with the konghq.com/plugins annotation on an Ingress, HTTPRoute, Service or KongConsumer. Note that plugin and config sit at the top level, not under spec.

49. How do you create a consumer and key credential with KIC?

apiVersion: v1
kind: Secret
metadata:
  name: mobile-app-key
  labels:
    konghq.com/credential: key-auth
stringData:
  key: change-me
---
apiVersion: configuration.konghq.com/v1
kind: KongConsumer
metadata:
  name: mobile-app
  annotations:
    kubernetes.io/ingress.class: kong
username: mobile-app
credentials:
  - mobile-app-key

KIC 3.x identifies the credential type from the konghq.com/credential label on the Secret.

50. Which annotations change Route behaviour in KIC?

Common ones are konghq.com/strip-path, konghq.com/preserve-host, konghq.com/methods, konghq.com/protocols, konghq.com/https-redirect-status-code and konghq.com/plugins. On the Kubernetes Service, annotations such as konghq.com/connect-timeout and konghq.com/retries set upstream behaviour.

51. How do you route traffic with the Gateway API instead of Ingress on Kong?

Create a GatewayClass handled by Kong's controller, a Gateway with listeners, and HTTPRoute resources that reference the Gateway in parentRefs and backend Services in backendRefs. Weights on backendRefs give traffic splitting without Kong-specific objects. Our Kubernetes gateways comparison shows how other controllers handle the same API.

52. How do you reference a secret from a vault in a plugin config?

Use a vault reference string in a referenceable field, for example {vault://env/redis-password} for an environment variable, or the AWS, GCP, Azure, HashiCorp or Conjur vault backends in Enterprise. kong vault get {vault://env/redis-password} tests resolution from the CLI.

53. What is the router_flavor setting?

It selects the routing engine. traditional_compatible (the default in 3.x) keeps the JSON route fields but runs on the newer ATC router. expressions lets you write Routes as expressions, for example http.path ^= "/api" && http.method == "GET", with an explicit priority field. Pick one per cluster and test before switching.

54. What does path_handling v0 vs v1 change?

It controls how the Service path and the remaining request path are joined when strip_path is used. v0 (default) and v1 differ in how slashes are combined, which can produce double slashes or missing slashes upstream. The expressions router supports only v0.

55. How do you redirect HTTP to HTTPS on a Route?

Set the Route's protocols to https only. Plain HTTP requests then get the status in https_redirect_status_code, which defaults to 426 (Upgrade Required). Change it to 301 or 308 for browsers so they follow the redirect.

56. How do you serve a TLS certificate for a domain?

Create a Certificate entity with the cert and key, then an SNI entity (or the snis array on the Certificate) for each hostname. Kong selects the certificate by the client's SNI. For automatic certificates, the acme plugin can obtain and renew them from Let's Encrypt.

Senior Kong questions: custom plugins and operations

57. What files make up a Lua custom plugin?

At minimum handler.lua, which returns a table with PRIORITY, VERSION and phase functions, and schema.lua, which defines the config fields. Plugins that store data add daos.lua and migrations. The module lives under kong.plugins.<name> on the Lua path.

58. Which phase functions can a plugin handler implement?

init_worker, certificate, rewrite, access, response, header_filter, body_filter and log for HTTP, with preread for stream traffic. Authentication and blocking logic go in access; logging goes in log, which runs after the response is sent.

59. Show a minimal handler that rejects requests without a header.

local RequireHeader = {
  PRIORITY = 900,
  VERSION = "1.0.0",
}

function RequireHeader:access(conf)
  local value = kong.request.get_header(conf.header_name)
  if not value then
    return kong.response.exit(400, { message = "missing " .. conf.header_name })
  end
  kong.service.request.set_header("X-Validated", "true")
end

return RequireHeader

kong.request, kong.response and kong.service.request are Plugin Development Kit (PDK) modules.

60. How do you install and enable a custom plugin?

Install the Lua module so it is on lua_package_path (a LuaRocks package, a mounted directory or a custom image), then add it to the plugins property: plugins = bundled,require-header. Restart or reload the nodes. In hybrid mode every data plane needs the plugin code, while the control plane needs at least the schema.

61. Which PDK functions do interviewers expect you to know?

kong.request.get_header, get_path and get_query; kong.response.exit and set_header; kong.service.request.set_header and set_path; kong.client.get_ip and get_consumer; kong.log.err and friends; kong.ctx.shared to pass data between plugins in one request; and kong.cache for caching lookups.

62. Can you write Kong plugins in languages other than Lua?

Yes. Kong provides PDKs for Go, Python (kong-python-pdk) and JavaScript, which run as external plugin servers that Kong talks to over a local socket. They add process overhead per call, so latency-sensitive plugins are usually written in Lua. See the custom plugin documentation.

63. How does PRIORITY affect a custom plugin?

Plugins run in descending PRIORITY order within each phase. Pick a value that places your plugin correctly relative to bundled plugins, for example after authentication if it needs the Consumer, by checking their priorities in the documentation. Enterprise also offers dynamic plugin ordering per plugin instance.

64. How do you test a custom plugin?

Kong's Pongo tool spins up Kong and its dependencies in Docker and runs Busted unit and integration tests against your plugin. Add kong check and a decK diff of a sample config to CI, and run load tests before enabling it on busy Routes.

65. What happens when you change kong.conf on a running node?

Nothing until you run kong reload or restart. Reload re-renders the NGINX configuration and starts new workers gracefully. Some changes, such as listen addresses in some cases, need a full restart; test in staging first.

66. How do you take a node out of a load balancer before maintenance?

Run kong drain, which makes /status/ready return 503 so the load balancer or Kubernetes readiness probe stops sending traffic. Wait for connections to finish, then kong quit. Point readiness checks at /status/ready on the Status API for this to work.

67. How do you size mem_cache_size and db_cache_ttl?

mem_cache_size (default 128m) holds entities and plugin lookups in shared memory; raise it when you have many Consumers or credentials and see cache misses. db_cache_ttl defaults to 0, meaning cached entities do not expire and are invalidated by cluster events instead. Watch memory per worker when you change either.

68. How do you generate certificates for a hybrid deployment?

kong hybrid gen_cert creates a shared certificate and key for the default shared cluster mode. Copy them to the control plane and every data plane and set cluster_cert and cluster_cert_key. For PKI mode, use certificates from your own CA and set cluster_mtls = pki. Hybrid concepts are covered in our sibling Kong API Gateway interview questions.

Scenario-based Kong troubleshooting questions

These scenarios cover configuration mistakes. For gateway-level failures such as 502, 503 ring-balancer errors and cluster-wide rate-limit drift, see the scenarios in our Kong API Gateway interview questions.

69. Clients get 401 "No API key found in request". The key exists. What do you check?

Check the header or query name the client uses against config.key_names (default apikey), whether a proxy in front strips custom headers, and whether the client sends it as a query string while key_in_query is disabled. Also confirm the key belongs to a Consumer in the same workspace.

70. Uploads fail with HTTP 413 at the gateway. Where do you look?

Look for a request-size-limiting plugin on the Route, Service or globally, and check its allowed_payload_size and size_unit. Also check NGINX body limits set through nginx_http_client_max_body_size. Raise limits on the upload Route only.

71. The backend returns 404 for every request through Kong, but works directly. What is the likely cause?

Path rewriting. With strip_path true, Kong removes the Route prefix, so /api/orders/42 reaches the backend as /42. Either set strip_path to false, or set the Service path to the prefix the backend expects. Compare upstream access logs with the client path to confirm.

72. A backend that hosts several sites serves the wrong site through Kong. Why?

Kong is sending the Service's host as the Host header. Set preserve_host to true on the Route (or konghq.com/preserve-host on Kubernetes) so the client's Host header reaches the backend.

73. A route for /users/123 is not matching a regex you configured. What is wrong?

Usually the tilde is missing, so Kong treats the regex as a literal prefix. Write it as ~/users/\d+$. If another regex Route also matches, set regex_priority so the more specific one is evaluated first.

74. Browser preflight requests fail even though the CORS plugin is enabled. What do you check?

Check that the Route accepts the OPTIONS method; if methods lists only GET and POST, the preflight never matches. Then check the origins list against the exact scheme and host, and that an auth plugin is not rejecting the unauthenticated OPTIONS request first.

75. proxy-cache is enabled but X-Cache-Status always shows Miss or Bypass. Why?

Bypass means the request or response is not cacheable under the config: wrong method, a status code not in response_code, a content type not in content_type, or Cache-Control headers when cache_control is honoured. Constant Miss with a memory strategy and several nodes is normal at first, since each node has its own cache.

76. After an upgrade Kong refuses to start and mentions pending migrations. What do you do?

Run kong migrations up from one node with the new version, start the new nodes, retire the old ones, then run kong migrations finish. Check kong migrations list to see what is pending. Take a database backup before any of this.

77. Ingress resources are created but Kong ignores them. What do you check first?

Whether spec.ingressClassName is kong (or matches the class KIC was installed with), then the KIC controller logs for translation errors and the Kubernetes events on the Ingress. A KongPlugin referenced in an annotation that does not exist in the same namespace also blocks configuration.

78. Logs and ip-restriction show the load balancer's IP for every client. How do you fix it?

Set trusted_ips to the load balancer's CIDRs and real_ip_header to X-Forwarded-For or proxy_protocol, depending on what the balancer sends, then reload. Verify with a request that logs kong.client.get_ip() or the log plugin's client IP field.

79. Kong logs "plugin is not enabled" when you apply a custom plugin config. Why?

The plugin is not listed in the plugins property on that node, or the Lua module is not on the Lua path. Add it (plugins = bundled,myplugin), make sure every node, including data planes, has the code, and reload.

Next steps

Kong work sits between Kubernetes, CI/CD and security. Our CKA training covers the cluster skills KIC depends on, and the DevOps training program covers pipelines, containers and monitoring. Both are taught in the Kharadi, Pune classroom and live online across India. For broader interview preparation, use the DevOps interview questions hub.

Frequently asked questions

How is this page different from the other Kong interview questions post?

This page is hands-on: Admin API calls, config fields, plugin settings, decK commands, KIC YAML and custom plugins. The Kong API Gateway interview questions post covers architecture, topologies, hybrid mode, Konnect and gateway-level failure scenarios.

Which ports does Kong use for the proxy and Admin API?

By default the proxy listens on 8000 (HTTP) and 8443 (HTTPS), and the Admin API on 127.0.0.1:8001 and 127.0.0.1:8444. The Status API defaults to 127.0.0.1:8007 and the hybrid cluster listener to 8005.

Can Kong still use Cassandra?

No. Cassandra support was removed in Kong Gateway 3.0. The database property accepts postgres or off (DB-less).

What is decK used for?

decK manages Kong configuration as declarative files. You dump, diff, validate and sync configuration against a gateway, which makes Kong config reviewable in Git and deployable from CI.

Do I need Lua to work with Kong?

Not for day-to-day work, which uses bundled plugins. Lua helps for custom plugins and senior roles. Kong also offers Go, Python and JavaScript PDKs.

How do I practise Kong for interviews?

Run Kong and Postgres in Docker, build Services, Routes and plugins with curl, move the config into a decK file in Git, then deploy the same setup with Kong Ingress Controller on a local Kubernetes cluster.

Where should Kong's Prometheus metrics be scraped from?

Enable the prometheus plugin and scrape /metrics on the Status API, which keeps monitoring off the Admin API.

Official references

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.