Aswin
02/25/2026, 9:13 AMkapa.ai
02/25/2026, 9:14 AMClient error : 413 Request Entity Too Large
This exact pattern (large schema / many tables → 413 / RESOURCE_EXHAUSTED) is documented as a UI/API limitation when loading very large catalogs. [UI table limit; MSSQL 413 issue]
What’s happening in your logs:
• The Postgres source completes discovery successfully (Completed integration, completed source).
• The sidecar then tries to “write catalog result to API…”.
• That call fails with 413 Request Entity Too Large and the discover workload is marked as failed. [MSSQL 413 issue]
Because the failure is at the API boundary, not in the connector, the root cause is the size of the discovered catalog (1 TB DB, 17k+ tables, CDC enabled on all).
Practical workarounds
Based on the available information, there is no documented server-side configuration in these sources to raise the limit, so the only reliable mitigations are to _reduce the size of each discover result_:
1. Split into multiple sources / connections
◦ Instead of one Postgres source covering the entire database, create several Postgres sources each limited to a subset of schemas or tables (e.g., by schema or functional domain).
◦ Each source will then produce a smaller catalog, staying under the payload limit.
2. Reduce the number of tables per source
◦ If possible, exclude non‑needed schemas/tables at the source definition level (e.g., only include specific schemas).
◦ This directly shrinks the discover catalog.
3. Limit CDC scope
◦ CDC adds extra metadata and configuration per stream; turning CDC on for every table in a 17k‑table DB is likely inflating the catalog.
◦ If feasible, enable CDC only for the tables you actually need in incremental/CDC mode; use full refresh for the rest.
4. Check for UI/catalog rendering limits
◦ There is prior guidance that loading more than ~6000 tables can cause resource exhaustion / large messages in the UI/API. [UI table limit]
◦ Keeping each source under that rough order of magnitude (or at least well below your current 17k) will help.
About the “will not sync in resumable full refresh mode” lines
Those log lines are informational: they just say certain streams won’t use Resumable Full Refresh (they’ll still sync, just without that feature). [Resumable FR]
They are not the cause of the failure; the actual failure is the 413 when writing the catalog.
-------------------------
Because the knowledge sources don’t document a configurable knob to increase the 413 limit, I can’t point you to a specific setting to change. If splitting the source/catalog is not acceptable in your environment, the next step would be to open a GitHub issue or support ticket referencing this 413 error and your catalog size, as this matches the known “too many tables / too large catalog” limitation. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
02/25/2026, 9:36 AMkapa.ai
02/25/2026, 9:36 AM413 Request Entity Too Large. [MSSQL 413]
Because the problem is the size of the discovered catalog, the only documented, reliable mitigation in the sources is to reduce how much is discovered per source:
1. Create multiple Postgres sources, each limited to a subset of the DB:
◦ For example:
▪︎ Source A: only schemas schema1, schema2, schema3
▪︎ Source B: only schemas schema4, schema5, etc.
◦ Keep each source to a much smaller number of tables (ideally well below the 17k you have now; note that even ~6000 tables has been reported as problematic for the UI/API). [UI table limit]
2. For each new source:
◦ Go through the normal “Set up source” flow.
◦ In the configuration, restrict which schemas/tables are included (if your version/connector allows schema filtering at setup).
◦ Run Discover again for that smaller subset.
3. Then:
◦ Create separate connections from each source to your destination.
◦ Select only the streams you need in each connection.
This directly shrinks the JSON catalog that the sidecar sends to the API, avoiding the 413.
-------------------------
2. Limit CDC to only the tables that really need it
CDC metadata also contributes to catalog size. With CDC turned on for all 17k+ tables, the catalog is very large.
Within each smaller source you create:
1. Enable CDC only for the tables that truly need log‑based incremental sync.
2. For less critical or rarely changing tables, use:
◦ Full refresh | overwrite or
◦ Full refresh | append (depending on your use case).
This reduces catalog complexity and may help keep each discover result under the size limit.
-------------------------
3. If you’re on a Helm/Kubernetes install, verify (but don’t rely on) timeout/size settings
The docs show how to increase timeouts for long‑running discovery, but they do not document a way to raise the HTTP body size limit that is causing your 413. [Scaling Airbyte]
If you’re already using Helm:
• You can ensure your values.yaml has something like:
server:
httpIdleTimeout: 20m
extraEnv:
- name: READ_TIMEOUT
value: 30m
(or extraEnvs depending on chart version). [Scaling Airbyte]
This helps if discovery is timing out, but it will not fix the 413 by itself according to the available docs.
-------------------------
4. If splitting still fails, involve support / open an issue
The knowledge sources don’t document a server‑side configuration to increase the 413 limit, so if:
• You’ve split the DB into multiple smaller sources, and
• Each source still fails discovery with 413 Request Entity Too Large,
then the next step is to:
1. Collect:
◦ Airbyte version
◦ Postgres source version
◦ Approx. number of tables per source
◦ The exact 413 stack trace (like you pasted)
2. Open a GitHub issue or support ticket referencing the known 413 catalog‑size problem. [MSSQL 413]
-------------------------
Summary of actions for you now
1. Do not try to discover the entire 1 TB / 17k‑table DB in a single source.
2. Create multiple Postgres sources, each limited to a subset of schemas/tables.
3. Enable CDC only where needed within each smaller source.
4. Re‑run discovery on each smaller source and then configure connections.
5. If a single smaller source still triggers 413, escalate with logs, as there’s no documented knob to raise that limit in the provided materials. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 10:52 AMkapa.ai
03/02/2026, 10:53 AMvalues.yaml configuration was attempted but did not fully resolve the issue for everyone: [MSSQL 413]
global:
env_vars:
HTTP_IDLE_TIMEOUT: 3600s
MICRONAUT_SERVER_MAX_REQUEST_SIZE: "104857600" # 100MB
webapp:
ingress:
annotations:
nginx.ingress.kubernetes.io/proxy-send-timeout: 3600
nginx.ingress.kubernetes.io/proxy-read-timeout: 3600
nginx.ingress.kubernetes.io/proxy-body-size: "50m"
server:
extraEnvs:
- name: HTTP_IDLE_TIMEOUT
value: 60m
- name: READ_TIMEOUT
value: 60m
You can try applying this if you haven't already, but the knowledge sources do not confirm this definitively resolves the 413 for large catalogs.
-------------------------
What the official docs recommend
For schema discovery timeouts/size issues, the documented approach is: [Scaling Airbyte]
server:
httpIdleTimeout: 20m
extraEnv:
- name: READ_TIMEOUT
value: 30m
-------------------------
What I cannot confirm from the knowledge sources
The knowledge sources do not document a definitive configuration knob that resolves the 413 body size limit when the catalog itself is too large. The 413 is happening at writeDiscoverCatalogResult — meaning the connector finishes successfully, but the result payload is rejected by the API server as too large. [MSSQL 413]
-------------------------
Recommended next steps
1. Try reducing further — even 1,000 tables with wide schemas (like the ones in your logs with 50+ columns each) and CDC metadata can produce a very large payload. Try 200–300 tables per source to see where the threshold is.
2. Open a GitHub issue or contact Airbyte support — this is a known but unresolved limitation. Provide:
◦ Your Airbyte version
◦ Postgres source version
◦ Number of tables per source
◦ The 413 stack trace
◦ Your current values.yaml configuration
3. Reference the existing MSSQL 413 issue as a related case: [MSSQL 413]
The knowledge sources do not contain a confirmed fix for this specific scenario beyond what's been shared above. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 10:53 AMkapa.ai
03/02/2026, 10:53 AMvalues.yaml settings (if you haven't already):
global:
env_vars:
HTTP_IDLE_TIMEOUT: 3600s
MICRONAUT_SERVER_MAX_REQUEST_SIZE: "104857600" # 100MB
webapp:
ingress:
annotations:
nginx.ingress.kubernetes.io/proxy-send-timeout: 3600
nginx.ingress.kubernetes.io/proxy-read-timeout: 3600
nginx.ingress.kubernetes.io/proxy-body-size: "50m"
server:
httpIdleTimeout: 20m
extraEnv:
- name: READ_TIMEOUT
value: 30m
[MSSQL 413; Scaling Airbyte]
2. Reduce tables further — your tables have very wide schemas (50+ columns each). Even 1,000 wide tables with CDC metadata can exceed the limit. Try 200–300 tables per source to find a working threshold.
3. Escalate to Airbyte — the knowledge sources do not document a confirmed fix for this at 1,000 tables. You should:
• Open a GitHub issue referencing both the Postgres discover issue (schema filter not respected) and the 413 issue
• Include your Airbyte version, Postgres source version, number of tables, and the 413 stack trace
The knowledge sources do not contain a confirmed resolution beyond what's listed above. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 11:07 AMkapa.ai
03/02/2026, 11:07 AMvalues.yaml is missing the MICRONAUT_SERVER_MAX_REQUEST_SIZE setting on the server level, and more importantly, the 413 is happening at the Airbyte API server (writeDiscoverCatalogResult), not at the nginx ingress. So increasing the nginx body size alone isn't enough — the Micronaut server itself is rejecting the payload.
Looking at your current config vs. what was attempted in the known 413 issue [MSSQL 413], here's what's missing:
Updated values.yaml to try
global:
airbyteUrl: https://airbyte.dbaas.testrun
env_vars:
HTTP_IDLE_TIMEOUT: 3600s
MICRONAUT_SERVER_MAX_REQUEST_SIZE: "104857600" # 100MB
webapp:
ingress:
annotations:
nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-body-size: "50m"
server:
httpIdleTimeout: 20m
extraEnv:
- name: READ_TIMEOUT
value: 30m
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "104857600" # 100MB — add this directly on the server pod
The key addition is MICRONAUT_SERVER_MAX_REQUEST_SIZE as an extraEnv on the server pod, not just as a global env var. The global env_vars block may not propagate to the server pod depending on your Helm chart version. [MSSQL 413]
-------------------------
Should you raise a GitHub issue?
Yes, you should. The knowledge sources confirm this is a known but unresolved limitation — the existing MSSQL 413 issue was closed without a confirmed fix for large catalogs, and there is a separate open Postgres issue about discover not respecting schema filters. [MSSQL 413; Postgres discover issue]
When raising the issue, include:
• Your Airbyte version
• Postgres source connector version
• Number of tables per source (you've tried 1,000)
• Your full values.yaml
• The 413 stack trace
• Reference to both issues above
-------------------------
In parallel: keep reducing table count
The knowledge sources do not confirm that any configuration change definitively resolves the 413 for large catalogs. Until a fix is confirmed, try reducing to 200–300 tables per source to find a working threshold while the issue is being investigated. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 11:11 AMkapa.ai
03/02/2026, 11:11 AMhelm upgrade airbyte airbyte/airbyte --namespace airbyte -f values.yaml
This uses the Helm chart V1 repository (airbyte/airbyte). If you're on Helm chart V2, the correct command is different: [Upgrading Airbyte]
# Helm chart V1
helm upgrade --install <RELEASE-NAME> airbyte/airbyte --values values.yaml --version <HELM-APP-VERSION>
# Helm chart V2
helm upgrade airbyte airbyte-v2/airbyte \
--namespace airbyte-v2 \
--values ./values.yaml \
--version 2.x.x
To verify which version you're on
Run:
helm list -n airbyte
This will show your current chart version. [Upgrading Airbyte]
-------------------------
After applying the upgrade
To confirm the new env vars are actually applied to the server pod, run:
kubectl describe pod -n airbyte -l app=airbyte-server | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
If MICRONAUT_SERVER_MAX_REQUEST_SIZE doesn't appear in the server pod's environment, the global env_vars block is not propagating to it, and you need the server.extraEnv addition from the previous recommendation.
-------------------------
Summary
• The command structure is fine for V1.
• Make sure you're targeting the right chart repo (V1 vs V2).
• After upgrade, verify the env var is present on the server pod before retrying discovery — that's the critical check to confirm the fix is actually applied. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 11:12 AMkapa.ai
03/02/2026, 11:13 AMkubectl describe pod -n airbyte -l app=airbyte-server | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE" returned no output confirms that the environment variable is not being applied to the server pod. This means your values.yaml change (putting MICRONAUT_SERVER_MAX_REQUEST_SIZE under global.env_vars) is not propagating to the server container.
Fix: Add it directly to the server pod via extraEnv
Update your values.yaml to explicitly set it on the server pod:
global:
airbyteUrl: https://airbyte.dbaas.testrun
env_vars:
HTTP_IDLE_TIMEOUT: 3600s
MICRONAUT_SERVER_MAX_REQUEST_SIZE: "104857600" # 100MB
webapp:
ingress:
annotations:
nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-body-size: "50m"
server:
httpIdleTimeout: 20m
extraEnv:
- name: READ_TIMEOUT
value: 30m
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "104857600" # 100MB — explicitly on the server pod
Then re-apply:
helm upgrade airbyte airbyte/airbyte --namespace airbyte -f values.yaml
After upgrade, verify it's applied
kubectl describe pod -n airbyte -l app=airbyte-server | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
You should now see the variable listed in the server pod's environment. If it appears, then retry your Postgres source discovery.
Also note: your multiple postgres-discover-* pods are all in Error state, which is consistent with the ongoing 413 failures. [MSSQL 413] Those will keep accumulating until the underlying issue is resolved — you can clean them up with:
kubectl delete pods -n airbyte -l app=airbyte-discover
or manually delete the errored pods once you're ready to retry. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.kapa.ai
03/02/2026, 11:13 AMapp=airbyte-server is returning "No resources found" — meaning the server pod doesn't have that label, so the grep command isn't finding the pod at all (let alone the env var).
Step 1: Find the correct label for the server pod
kubectl describe pod -n airbyte airbyte-server-d7dbf6695-lvbqt | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
Use the exact pod name from your kubectl get pods output (airbyte-server-d7dbf6695-lvbqt).
Step 2: Check if the env var is present
If the above returns nothing, the server.extraEnv change is still not being applied. In that case, also check what env vars the server pod currently has:
kubectl describe pod -n airbyte airbyte-server-d7dbf6695-lvbqt | grep -A1 "MICRONAUT\|MAX_REQUEST"
Step 3: Confirm your chart version
From your helm list output, you are on Helm chart V1 (airbyte-1.9.2, app version 2.0.1). [Upgrading Airbyte]
For Helm chart V1, the correct key is extraEnvs (with an s), not extraEnv. Make sure your values.yaml uses:
server:
httpIdleTimeout: 20m
extraEnvs:
- name: READ_TIMEOUT
value: 30m
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "104857600"
Note the extraEnvs (plural) — this is the V1 syntax. [MSSQL 413]
Step 4: Re-apply and verify
helm upgrade airbyte airbyte/airbyte --namespace airbyte -f values.yaml
Then wait for the server pod to restart and verify with the pod name directly:
kubectl describe pod -n airbyte airbyte-server-d7dbf6695-lvbqt | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
The new pod name will change after the upgrade — re-run kubectl get pods -n airbyte to get the new server pod name first. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 11:13 AMkapa.ai
03/02/2026, 11:13 AMairbyte-server-d7dbf6695-lvbqt) and AGE is 14m — which means the server pod did not restart after your last helm upgrade. This is why the env var isn't showing up: the old pod is still running with the old configuration.
Step 1: Check if the server pod restarted
kubectl get pods -n airbyte | grep airbyte-server
If the pod name and AGE haven't changed since your upgrade, the deployment wasn't updated (possibly because Helm didn't detect a change that would trigger a rollout).
Step 2: Force a rollout restart of the server
kubectl rollout restart deployment/airbyte-server -n airbyte
Then wait for the new pod to come up:
kubectl get pods -n airbyte -w
Step 3: Get the new pod name and verify the env var
Once the new pod is running:
kubectl get pods -n airbyte | grep airbyte-server
Then use the new pod name to check:
kubectl describe pod -n airbyte <new-server-pod-name> | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
Step 4: Also confirm your values.yaml uses extraEnvs (plural)
You are on Helm chart V1 (airbyte-1.9.2). The correct key in V1 is extraEnvs (with an s): [Upgrading Airbyte]
server:
httpIdleTimeout: 20m
extraEnvs:
- name: READ_TIMEOUT
value: 30m
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "104857600"
If you had extraEnv (without the s), Helm chart V1 would silently ignore it, which would explain why the env var never appeared on the pod. Fix the key, re-run helm upgrade, then force the rollout restart. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 11:27 AMkapa.ai
03/02/2026, 11:28 AMkubectl get pods -n airbyte | grep airbyte-server
Then check if MICRONAUT_SERVER_MAX_REQUEST_SIZE is present:
kubectl describe pod -n airbyte <current-server-pod-name> | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
2. Wait for the discover pod to finish and check its logs
The logs you pasted show the discover is still in progress (----- START DISCOVER -----). Wait for it to complete, then check the result:
kubectl logs -n airbyte <postgres-discover-pod-name> -c connector-sidecar
Look for either:
• Writing catalog result to API... followed by success → the fix worked
• Client error : 413 Request Entity Too Large → the env var is still not applied to the server
3. If still 413 — confirm your values.yaml uses extraEnvs (plural)
You are on Helm chart V1 (airbyte-1.9.2). The correct syntax is extraEnvs with an s: [MSSQL 413]
server:
httpIdleTimeout: 20m
extraEnvs:
- name: READ_TIMEOUT
value: 30m
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "104857600"
And force a restart if the pod hasn't cycled since your last upgrade:
kubectl rollout restart deployment/airbyte-server -n airbyte
The key thing to confirm is whether MICRONAUT_SERVER_MAX_REQUEST_SIZE is actually visible in the server pod's environment — that's the definitive check before concluding whether the fix is applied or not. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/02/2026, 11:34 AMAswin
03/02/2026, 11:34 AMkapa.ai
03/02/2026, 11:34 AMAswin
03/02/2026, 2:33 PMkapa.ai
03/02/2026, 2:34 PMMICRONAUT_SERVER_MAX_REQUEST_SIZE to the server pod ✅
• Applied nginx ingress size/timeout settings ✅
• Applied httpIdleTimeout and READ_TIMEOUT ✅
• Split to ~1,000 tables per source ✅
-------------------------
Remaining Options
1. Check if the latest discover actually succeeded
First, confirm whether the fix worked for the current running discover:
kubectl get pods -n airbyte | grep postgres-discover
kubectl logs -n airbyte <latest-discover-pod-name> -c connector-sidecar | tail -50
Look for success or another 413.
2. If still failing — reduce tables further
1,000 tables with 50+ columns each still produces a very large catalog payload. Try 200–300 tables per source to find a working threshold. [MSSQL 413]
3. Limit CDC scope
CDC metadata inflates the catalog significantly. Enable CDC *only on tables that truly need it*; use full refresh for the rest. This directly reduces catalog payload size.
4. Open a GitHub issue with Airbyte
The knowledge sources do not document a confirmed fix beyond what you've already applied. [MSSQL 413] You should escalate with:
• Airbyte version: 2.0.1
• Helm chart: airbyte-1.9.2
• Postgres source version
• Number of tables per source (tried 1,000)
• Your values.yaml
• The 413 stack trace
• Reference to the existing 413 issue
-------------------------
The most actionable immediate step is to check the current discover pod logs to confirm whether the env var fix resolved it, and if not, reduce to 200–300 tables per source while raising a GitHub issue in parallel. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/03/2026, 4:50 PMMICRONAUT_SERVER_MAX_REQUEST_SIZE to 500 MB, but I am still facing the same issue. How can I overcome this?
Also, since each source connection has its own publication name and we run the ALTER PUBLICATION command for those 200 tables, how will enabling the CDC option for 80% of the tables affect this?
Only the data of those 200 tables included in the publication would be considered for source discovery and data input, right?
Will providing any log dumps help you identify the core problem so that I can proceed further?
If so, please let me know the steps to collect and share themkapa.ai
03/03/2026, 4:50 PMkubectl get pods -n airbyte | grep airbyte-server
kubectl describe pod -n airbyte <server-pod-name> | grep -A2 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
Confirm the value shows 524288000 (500MB in bytes) or "524288000".
-------------------------
2. CDC with publications and 200 tables
Yes, your understanding is correct. When you create a Postgres source with a specific publication name and run:
ALTER PUBLICATION <publicationName> ADD TABLE <table1>, <table2>, ...;
Only the tables included in that publication are tracked for CDC changes. [Postgres troubleshooting]
However, there are important CDC requirements to be aware of:
• CDC only works for tables with primary keys. Tables without primary keys must use Full Refresh sync. [Postgres troubleshooting]
• Each Airbyte CDC source should only connect to one destination — multiple destinations would each receive only part of the data. [Postgres troubleshooting]
• Schema changes are not supported automatically for CDC — you'd need to reset and resync if schema changes occur. [Postgres troubleshooting]
So enabling CDC for 80% of the 200 tables is fine as long as those tables have primary keys. The publication controls what's tracked at the Postgres level.
-------------------------
3. Log collection to identify the core problem
Yes, sharing logs would help narrow down whether the issue is:
• The catalog payload still being too large (413 at writeDiscoverCatalogResult)
• A different error entirely
Steps to collect relevant logs:
a) Get the latest discover pod name:
kubectl get pods -n airbyte | grep postgres-discover
b) Get logs from the connector sidecar container:
kubectl logs -n airbyte <postgres-discover-pod-name> discover-sidecar.log
c) Get logs from the connector container:
kubectl logs -n airbyte <postgres-discover-pod-name> discover-connector.log
d) Get server logs around the time of the failure:
kubectl logs -n airbyte <airbyte-server-pod-name> server.log
e) Confirm the env var on the server pod:
kubectl describe pod -n airbyte <airbyte-server-pod-name> server-describe.txt
Share the tail of discover-sidecar.log (last 100 lines) — specifically the section around Writing catalog result to API... — as that will confirm whether the 413 is still the root cause or if something else has changed.
-------------------------
4. Recommended next step regardless
Since you've exhausted the documented configuration options, open a GitHub issue on the Airbyte repository referencing the existing 413 issue and the Postgres discover issue. Include your Airbyte version (2.0.1), table count (200), column counts, MICRONAUT_SERVER_MAX_REQUEST_SIZE value, and the stack trace. The knowledge sources do not document a confirmed resolution for this at your scale. [MSSQL 413; Postgres discover issue] 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:19 PMkapa.ai
03/04/2026, 12:20 PM----- START CHECK -----
This is normal startup/initialization output for the connector sidecar. The logs you've shared here show:
• Micronaut environment initialized (worker-v2, control-plane, oss, local-secrets) ✅
• Log levels configured ✅
• Workload transitioned to running state ✅
• Connector exited and output is being processed ✅
• CHECK operation started ✅
These logs by themselves do not show an error. They are cut off before the CHECK completes, so we can't tell from this snippet whether it succeeded or failed.
What to do
Get the full logs from this pod to see the outcome:
kubectl logs -n airbyte <pod-name> -c connector-sidecar
Look for either:
• ✅ A success message indicating the connection check passed
• ❌ A 413 Request Entity Too Large or other error at the end
These initialization logs are not the cause of your issue — the 413 error in your case always appears at the very end, at the writeDiscoverCatalogResult step, not during startup. [MSSQL 413]
Can you share the tail end of the full logs (last 50–100 lines) from the discover pod? That's where the actual error or success will appear. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:23 PMkapa.ai
03/04/2026, 12:23 PMMICRONAUT_SERVER_MAX_REQUEST_SIZE is still not actually being applied to the server pod, regardless of what's in your values.yaml.
Step 1: Definitively confirm the env var on the server pod
kubectl get pods -n airbyte | grep airbyte-server
kubectl exec -n airbyte <server-pod-name> -- env | grep MICRONAUT
This directly reads the environment inside the running container. If MICRONAUT_SERVER_MAX_REQUEST_SIZE does not appear here, the setting is not applied — full stop.
Step 2: Check the actual error in the discover pod logs
With only 10 tables, the payload cannot be large enough to cause a genuine 413 size limit. This means either:
• The size limit is still at its default (very small), OR
• The error is something different now (not actually a size issue)
Get the full logs from the latest discover pod:
kubectl get pods -n airbyte | grep postgres-discover
kubectl logs -n airbyte <latest-discover-pod-name> -c connector-sidecar
Share the last 50 lines — the actual error message at the end will tell us what's really happening.
Step 3: Check the server logs at the time of failure
kubectl logs -n airbyte <server-pod-name> --since=10m | grep -i "413\|error\|request"
-------------------------
The knowledge sources do not document a scenario where 10 tables causes a genuine 413 payload size error. [MSSQL 413] At this point, the most likely explanation is that the MICRONAUT_SERVER_MAX_REQUEST_SIZE setting is not reaching the server pod. Please share the output of the kubectl exec env check and the tail of the discover pod logs so we can identify the actual root cause. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:27 PMkapa.ai
03/04/2026, 12:27 PMCaused by: org.openapitools.client.infrastructure.ClientException: Client error : 413 Request Entity Too Large
at io.airbyte.api.client.generated.SourceApi.writeDiscoverCatalogResult(SourceApi.kt:1090)
This error occurs when the connector sidecar pod tries to send the discovered catalog back to the Airbyte API server — this is entirely a backend communication issue between pods, not anything related to your browser or browser cache. [MSSQL 413]
Clearing your browser cache or switching browsers will have no effect on this error.
-------------------------
While you wait for the new discovery logs
Please run these two commands and share the output — they are the most critical checks right now:
1. Confirm the env var is actually inside the server container:
kubectl exec -n airbyte <server-pod-name> -- env | grep MICRONAUT
2. Get the tail of the new discover pod logs once it finishes:
kubectl get pods -n airbyte | grep postgres-discover
kubectl logs -n airbyte <latest-discover-pod-name> -c connector-sidecar | tail -50
The fact that even 10 tables fails strongly suggests MICRONAUT_SERVER_MAX_REQUEST_SIZE is not actually applied to the running server container, and the kubectl exec command above will confirm this definitively. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:29 PMkapa.ai
03/04/2026, 12:29 PMAswin
03/04/2026, 12:30 PMkapa.ai
03/04/2026, 12:30 PMMICRONAUT_SERVER_MAX_REQUEST_SIZE=104857600
That's 100MB — not 500MB as you mentioned trying earlier. If you intended to set 500MB, the value should be 524288000. But more importantly, even 100MB should be more than enough for 10 tables.
This means the MICRONAUT_SERVER_MAX_REQUEST_SIZE is applied correctly, and the 413 with only 10 tables is not a payload size issue. Something else is causing the failure.
-------------------------
What we need now: the discover pod logs (part 2 of your output)
You mentioned you were pasting the output — it looks like the second part got cut off. Please share the output of:
kubectl get pods -n airbyte | grep postgres-discover
kubectl logs -n airbyte <latest-discover-pod-name> -c connector-sidecar | tail -80
Also check the server logs at the time of the failure:
kubectl logs -n airbyte airbyte-server-5bbdbb9ff8-7qrkw --since=15m | grep -i "413\|error\|request\|entity"
-------------------------
Why this matters
With 10 tables and 100MB limit confirmed on the server, the 413 should not be a size issue. The server logs may reveal what the actual rejection reason is — it could be a different endpoint, a different size limit, or a completely different error being misreported as 413. [MSSQL 413]
Please paste the remaining logs you were sharing. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:31 PMkapa.ai
03/04/2026, 12:31 PMAswin
03/04/2026, 12:31 PMkapa.ai
03/04/2026, 12:31 PMMICRONAUT_SERVER_MAX_REQUEST_SIZE=104857600 (100MB) is confirmed on the server pod, yet even 10 tables fails with 413. This means the 413 is not being rejected by the Airbyte server — it's being rejected by something in front of it, most likely the airbyte-workload-api-server pod, not airbyte-server.
Look at the stack trace carefully:
at io.airbyte.api.client.generated.SourceApi.writeDiscoverCatalogResult(SourceApi.kt:1090)
The connector sidecar is calling the Workload API / Source API, which may be a different service with its own size limit — not the main airbyte-server you've been configuring. [MSSQL 413]
Step 1: Check the workload-api-server pod for the env var
kubectl exec -n airbyte airbyte-workload-api-server-65c5dc68d8-8v4qk -- env | grep MICRONAUT
If MICRONAUT_SERVER_MAX_REQUEST_SIZE is missing or small on this pod, that's your root cause.
Step 2: Add the setting to workload-api-server in values.yaml
workload-api-server:
extraEnvs:
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "524288000" # 500MB
Then re-apply:
helm upgrade airbyte airbyte/airbyte --namespace airbyte -f values.yaml
Step 3: Verify after upgrade
kubectl exec -n airbyte <new-workload-api-server-pod-name> -- env | grep MICRONAUT
-------------------------
The knowledge sources do not explicitly document the workload-api-server size limit configuration, but the stack trace clearly shows the 413 originates from SourceApi.writeDiscoverCatalogResult — which communicates with the workload API layer, not the main server. [MSSQL 413] This is the most likely explanation for why configuring MICRONAUT_SERVER_MAX_REQUEST_SIZE on airbyte-server alone has had no effect. 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:35 PMkapa.ai
03/04/2026, 12:35 PMvalues.yaml looks mostly right, but there are a few things to fix:
Issues to address
1. MICRONAUT_SERVER_MAX_REQUEST_SIZE is commented out under global.env_vars — that's fine since you're setting it directly on the pods, but make sure it's intentional.
2. server.extraEnv should be server.extraEnvs (plural) — you're on Helm chart V1 (airbyte-1.9.2). The correct key is extraEnvs with an s. Using extraEnv (without the s) may be silently ignored. [Scaling Airbyte]
3. workload-api-server.extraEnvs uses the correct plural form ✅ — keep this as is.
Corrected values.yaml
global:
airbyteUrl: https://airbyte.dbaas.testrun
env_vars:
HTTP_IDLE_TIMEOUT: 3600s
webapp:
ingress:
annotations:
nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-body-size: "500m" # increase this too
server:
httpIdleTimeout: 20m
extraEnvs: # <-- plural (was extraEnv)
- name: READ_TIMEOUT
value: 30m
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "524288000" # 500MB
workload-api-server:
extraEnvs:
- name: MICRONAUT_SERVER_MAX_REQUEST_SIZE
value: "524288000" # 500MB
Key changes
• server.extraEnv → server.extraEnvs (plural, required for Helm chart V1)
• nginx.ingress.kubernetes.io/proxy-body-size increased to "500m" to match the 500MB limit you're setting on the backend pods
After applying
helm upgrade airbyte airbyte/airbyte --namespace airbyte -f values.yaml
Then verify both pods have the setting:
kubectl exec -n airbyte <server-pod-name> -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
kubectl exec -n airbyte <workload-api-server-pod-name> -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
Both should return 524288000. [MSSQL 413] 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:39 PMkubectl exec -n airbyte <server-pod-name> -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
kubectl exec -n airbyte <workload-api-server-pod-name> -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZEkapa.ai
03/04/2026, 12:39 PMairbyte namespace and find the exact names:
kubectl get pods -n airbyte
From your previous output, the pod names are already visible:
• Server pod: airbyte-server-5bbdbb9ff8-7qrkw (or whatever the current name is after the latest upgrade)
• Workload API server pod: airbyte-workload-api-server-65c5dc68d8-8v4qk (or current name)
So the commands to run are:
kubectl exec -n airbyte airbyte-server-5bbdbb9ff8-7qrkw -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
kubectl exec -n airbyte airbyte-workload-api-server-65c5dc68d8-8v4qk -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
> Note: After running helm upgrade, the pod names will change (the random suffix changes on restart). Always run kubectl get pods -n airbyte first to get the current pod names before running the exec commands. [Developing Locally] 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:43 PMkapa.ai
03/04/2026, 12:44 PMMICRONAUT_SERVER_MAX_REQUEST_SIZE is not being applied to either pod after your latest helm upgrade. The values.yaml changes are not taking effect.
Diagnose why the values aren't being applied
Step 1: Confirm what values Helm is actually using
helm get values airbyte -n airbyte
This shows what values Helm has recorded for your current release. Check if workload-api-server.extraEnvs and server.extraEnvs appear there.
Step 2: Check if the correct values file was used in the upgrade
helm get manifest airbyte -n airbyte | grep -A5 "MICRONAUT_SERVER_MAX_REQUEST_SIZE"
This shows the actual rendered Kubernetes manifests. If the env var doesn't appear here, Helm never rendered it into the deployment.
Step 3: Manually patch the pods as a temporary workaround
While you investigate the Helm issue, you can patch the deployments directly:
kubectl set env deployment/airbyte-server -n airbyte MICRONAUT_SERVER_MAX_REQUEST_SIZE=524288000
kubectl set env deployment/airbyte-workload-api-server -n airbyte MICRONAUT_SERVER_MAX_REQUEST_SIZE=524288000
Then verify:
kubectl exec -n airbyte <new-server-pod-name> -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
kubectl exec -n airbyte <new-workload-api-server-pod-name> -- env | grep MICRONAUT_SERVER_MAX_REQUEST_SIZE
> Note: This direct patch will be overwritten the next time you run helm upgrade, so it's only a temporary test to confirm whether the env var on workload-api-server is the actual fix.
Step 4: After patching, retry discovery
Trigger a new discovery on your 10-table source and check if the 413 is resolved. If it succeeds, that confirms the workload-api-server was the missing piece, and you can then focus on getting the Helm values to apply correctly. [MSSQL 413] 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.Aswin
03/04/2026, 12:58 PMkapa.ai
03/04/2026, 12:58 PMwriteDiscoverCatalogResult.
3. That HTTP request is rejected with 413 because the catalog payload exceeds the server's configured maximum request size. [MSSQL 413]
The exact error in your logs is:
Caused by: org.openapitools.client.infrastructure.ClientException: Client error : 413 Request Entity Too Large
at io.airbyte.api.client.generated.SourceApi.writeDiscoverCatalogResult(SourceApi.kt:1090)
Why it happens in your setup
• Your database has a very large number of tables with wide schemas (many columns each).
• The JSON catalog representing all those tables and their schemas becomes a very large payload.
• The Airbyte API server (and/or the workload API server) has a default maximum request size that this payload exceeds. [MSSQL 413]
What controls the limit
The relevant setting is MICRONAUT_SERVER_MAX_REQUEST_SIZE, which needs to be applied to both:
• airbyte-server pod
• airbyte-workload-api-server pod
Based on our conversation, the env var is currently not being applied to either pod despite your values.yaml changes, which is why even 10 tables still fails. The immediate next step is to patch the deployments directly to test:
kubectl set env deployment/airbyte-server -n airbyte MICRONAUT_SERVER_MAX_REQUEST_SIZE=524288000
kubectl set env deployment/airbyte-workload-api-server -n airbyte MICRONAUT_SERVER_MAX_REQUEST_SIZE=524288000 👍 0 button 👎 0 button ℹ️ Tip: Mention @kapa.ai in the thread for follow-ups or DM the app for 1-to-1 help.