# Serwery MCP chmur i platform: AWS, Azure, Google Cloud, Vercel i Stripe

URL: https://developertoolkit.ai/pl/ecosystem/mcp/cloud-platform-mcp/
Description: Podłącz Claude Code, Codeksa i Cursora do AWS, Azure, Google Cloud, Vercela i Stripe'a przez tożsamości tylko do odczytu, przypięte wersje i twarde dowody.

Serwery MCP chmur i platform pozwalają Claude Code, Codeksowi i Cursorowi odczytać żywy stan AWS, Azure, Google Cloud, Vercela i Stripe'a zamiast go zgadywać. We wrześniu 2026 każdy z tych dostawców ma oficjalny serwer, zwykle w pluginie razem ze skillami. Bezpieczny jest tylko za tożsamością tylko do odczytu, z przypiętą wersją i deterministycznym sprawdzeniem odpowiedzi agenta.

Ta strona jest dla programistów i tech leadów, u których agent pisze kod, ale nie widzi platformy, na której ten kod działa: proponuje aktualizację Lambd, nie wiedząc, które funkcje istnieją, albo „naprawia” nieudany preview na Vercelu, zgadując treść logu, którego nigdy nie przeczytał. Serwer dostawcy zamyka tę lukę, ale każdy z nich potrafi też usuwać, wdrażać albo obciążać kartę z twoimi uprawnieniami. Poniższa konfiguracja daje agentowi najpierw oczy, a ręce tylko przez CI.

**Sprawdzone 26 września 2026**

Składnia poleceń odpowiada Claude Code 2.1.283 i codex-cli 0.157.1. Wersje pakietów pochodzą z npm i PyPI, a zawartość pluginów z manifestów w `claude-plugins-official` i z repozytoriów dostawców na GitHubie. Konfiguracje dla Cursora odpowiadają README dostawców.

## Co daje ta konfiguracja

- Tożsamość tylko do odczytu dla każdej platformy (profil AWS, flaga serwera Azure, konto usługi Google, ograniczony klucz Stripe'a), przez którą łączy się każdy serwer z tej strony
- Sprawdzone polecenia instalacji AWS MCP Server, Azure MCP Server przypiętego do stabilnego wydania, gcloud MCP, Vercel MCP i Stripe MCP we wszystkich trzech agentach
- Audyt runtime'ów Lambd tylko do odczytu, którego wynik sprawdzasz jednym zapytaniem AWS CLI, a nie czytając podsumowanie agenta
- Cykliczne sprawdzanie dryfu Terraformu, które oznacza zadanie CI jako nieudane, gdy wykryje dryf w Azure
- Pełną pętlę dla nieudanego wdrożenia preview na Vercelu: logi przez MCP, lokalne odtworzenie błędu, poprawka, ponowne wdrożenie i smoke test
- Pułapki, w tym tag `latest` w npm, który jest betą, i plugin, który tę betę uruchamia

## Którego serwera MCP chmury lub platformy potrzebujesz?

Wybierz według miejsca, w którym działa twój kod. Każdy serwer poniżej pochodzi od samego dostawcy. Popularność: gwiazdki z API GitHuba i instalacje z katalogu Claude Marketplace (`claude.com/plugins`), zapisane 26.09.2026 w dossier badawczych serwisu.

| Platforma | Serwer | Transport i uwierzytelnianie | Kontrola trybu tylko do odczytu | Popularność (26.09.2026) |
| --- | --- | --- | --- | --- |
| **AWS** | AWS MCP Server przez Agent Toolkit for AWS (plugin `aws-core`) | Lokalne proxy `uvx`, które podpisuje żądania SigV4 do `https://aws-mcp.us-east-1.api.aws/mcp` | Tożsamość IAM za `--profile`; flaga proxy `--read-only` | `aws/agent-toolkit-for-aws` ★2.7k, `awslabs/mcp` ★9.7k |
| **Dokumentacja AWS** | AWS Knowledge MCP | Zdalny `https://knowledge-mcp.global.api.aws`, bez uwierzytelniania, z limitem zapytań | Tylko dokumentacja | część `awslabs/mcp` |
| **Azure** | Azure MCP Server (`@azure/mcp`) | Lokalny stdio, twoja tożsamość Azure (`az login`) | `--read-only` na serwerze oraz RBAC | `microsoft/mcp` ★3.7k |
| **Google Cloud** | gcloud MCP (`@google-cloud/gcloud-mcp`) oraz endpointy hostowane przez Google | Lokalny stdio z twoim kontem gcloud; endpointy hostowane używają Google OAuth | Impersonacja konta usługi z rolą viewer | `googleapis/gcloud-mcp` ★914 |
| **Vercel** | Vercel MCP | Zdalny `https://mcp.vercel.com`, OAuth | Tylko odczyt w pierwszym wydaniu (według manifestu pluginu Vercela) | plugin `vercel`: 227 688 instalacji |
| **Stripe** | Stripe MCP | Zdalny `https://mcp.stripe.com` (OAuth) lub lokalny `@stripe/mcp` | Sandbox lub tryb testowy oraz ograniczony klucz API dla serwera lokalnego | `stripe/ai` ★1.8k; plugin `stripe`: 61 066 instalacji |

Cloudflare ma własną stronę, [serwery MCP Cloudflare](/pl/ecosystem/mcp/cloudflare-mcp/), a Terraform, Kubernetes i Docker opisuje strona o [serwerach MCP dla infrastruktury](/pl/ecosystem/mcp/infrastructure-mcp/).

## Utwórz tożsamość tylko do odczytu, zanim cokolwiek podłączysz

Każdy serwer chmury działa jako ten, na kogo się uwierzytelni. Jeśli to twój login administratora, agent jest administratorem. Najpierw przygotuj wąską tożsamość, bo flagę serwera można źle wpisać, a aktualizacja pluginu może zmienić domyślne ustawienie, natomiast rola IAM obowiązuje dalej.

| Platforma | Tożsamość do utworzenia | Jak serwer ją odczytuje |
| --- | --- | --- |
| AWS | Rola IAM z zarządzaną polityką AWS `ReadOnlyAccess` (lub węższą własną), przyjmowana przez profil `agent-readonly` | `--profile agent-readonly` w proxy albo `AWS_MCP_PROXY_PROFILES="agent-readonly"` w środowisku dla pluginu |
| Azure | We własnych sesjach flaga serwera `--read-only`; w automatyzacji service principal z rolą **Reader** na jednej grupie zasobów | Sesja `az login` albo zmienne środowiskowe Azure Identity |
| Google Cloud | Konto usługi z `roles/viewer` na jednym projekcie | `gcloud config set auth/impersonate_service_account agent-viewer@PROJECT_ID.iam.gserviceaccount.com` |
| Vercel | Twoje konto Vercela, ograniczone do zespołu wybranego podczas OAuth | OAuth w przeglądarce przy pierwszym połączeniu |
| Stripe | Konto sandbox (lub tryb testowy); dla serwera lokalnego ograniczony klucz (`rk_test_…`) | OAuth do sandboxa albo `STRIPE_SECRET_KEY` w środowisku |

Profil AWS w `~/.aws/config` wygląda tak (rola i numer konta są twoje):

```ini
[profile agent-readonly]
role_arn = arn:aws:iam::123456789012:role/AgentReadOnly
source_profile = default
region = eu-west-1
```

**Tylko do odczytu nadal czyta sekrety**

`ReadOnlyAccess` czyta dane, nie tylko konfigurację: `lambda list-functions` zwraca zmienne środowiskowe, a `s3:GetObject` zawartość plików, i wszystko to trafia do transkryptu sesji. Trzymaj sekrety w Secrets Managerze lub Key Vaulcie i każ agentowi ich nie wypisywać, tak jak robią to prompty poniżej.

## Podłącz AWS przez Agent Toolkit for AWS

Agent Toolkit for AWS (`aws/agent-toolkit-for-aws`, odznaka „GA”) to rozwiązanie, które AWS poleca dziś zamiast starszych serwerów `awslabs`. Jego plugin `aws-core` konfiguruje zarządzany AWS MCP Server i 25 skilli AWS (wersja 1.1.0). Serwer ma cztery narzędzia: `search_documentation` i `retrieve_skill` (bez uwierzytelniania), `call_aws` (ponad 300 usług AWS) oraz `run_script` (Python w piaskownicy). AWS zapisuje każde żądanie w CloudTrail i dodaje klucze warunków IAM, które odróżniają działania agenta od działań człowieka.

**Claude Code**

```bash
# In a Claude Code session: the plugin brings the server and the skills
/plugin install aws-core@claude-plugins-official
/reload-plugins
```

Jeśli instalacja zgłosi, że nie ma takiego marketplace'u, uruchom `claude plugin marketplace add anthropics/claude-plugins-official` i spróbuj ponownie. Plugin uruchamia proxy z `--skip-auth` i bez profilu, więc korzysta z domyślnego łańcucha poświadczeń. Wskaż mu rolę tylko do odczytu, zanim uruchomisz `claude`:

```bash
export AWS_MCP_PROXY_PROFILES="agent-readonly"
```

Możesz też pominąć plugin i dodać sam serwer, z profilem w linii poleceń:

```bash
claude mcp add aws-mcp -- uvx mcp-proxy-for-aws-cli@latest \
  https://aws-mcp.us-east-1.api.aws/mcp --profile agent-readonly --region eu-west-1
```

**Codex**

```bash
# Terminal: add AWS's marketplace, then install aws-core from it
codex plugin marketplace add aws/agent-toolkit-for-aws
codex plugin add aws-core@agent-toolkit-for-aws
```

Możesz też wybrać `aws-core` z `/plugins` w Codeksie albo dodać sam serwer:

```bash
codex mcp add aws-mcp -- uvx mcp-proxy-for-aws-cli@latest \
  https://aws-mcp.us-east-1.api.aws/mcp --profile agent-readonly --region eu-west-1
```

**Cursor**

Według README AWS: **Settings → Plugins → Team Marketplaces → Add Marketplace → Import from Repo**, wskaż `aws/agent-toolkit-for-aws`, a potem zainstaluj `aws-core` z panelu **Plugins**. Sam serwer dodasz w `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "args": ["mcp-proxy-for-aws-cli@latest", "https://aws-mcp.us-east-1.api.aws/mcp",
               "--profile", "agent-readonly", "--region", "eu-west-1"]
    }
  }
}
```

`mcp-proxy-for-aws-cli` (PyPI 1.7.0) to dystrybucja proxy z przypiętymi wersjami: nawet `@latest` instaluje zamrożone drzewo zależności. Jeśli chodzi ci tylko o dokumentację, AWS Knowledge MCP nie wymaga poświadczeń: `claude mcp add --transport http aws-knowledge https://knowledge-mcp.global.api.aws` (albo `codex mcp add aws-knowledge --url https://knowledge-mcp.global.api.aws`).

### Przeprowadź audyt runtime'ów Lambd bez dotykania czegokolwiek

Od tego przykładu warto zacząć: działa tylko do odczytu, a wynik to lista, którą sprawdzisz jednym poleceniem.

**Prompt do skopiowania: funkcje Lambda nadal na nodejs18.x**

```text
Use the aws-mcp server with the agent-readonly profile. Read-only: do not call any create, update, delete, put or invoke operation.
List every Lambda function in eu-west-1 whose Runtime is nodejs18.x (paginate until NextMarker is empty).
For each one, report: function name, last modified date, memory, architecture, and the layers it uses. Do not print environment variables.
Then search the AWS documentation for the current supported Node.js runtimes and draft an upgrade plan to the newest one: order the functions by risk (layers with native modules first), list what to test for each, and give the exact `aws lambda update-function-configuration` command per function without running it.
End with the CLI query I can run to confirm your list.
```

Dostajesz tabelę funkcji, plan pogrupowany według ryzyka i końcowe zapytanie CLI. Uruchom je albo to poniżej i porównaj nazwy:

```bash
# Terminal: deterministic cross-check of the agent's list
aws lambda list-functions --region eu-west-1 --profile agent-readonly \
  --query "Functions[?Runtime=='nodejs18.x'].FunctionName" --output text
```

Jeśli listy się różnią, agent przerwał paginację albo filtrował po złym polu. To porównanie jest weryfikacją. Sama zmiana runtime'u trafia do produkcji jako pull request z infrastrukturą jako kodem (SAM, CDK lub Terraform), który wdraża CI, a nie jako wywołanie `update-function-configuration` na żywym koncie.

Proxy ma też flagę `--read-only`, która odrzuca każde narzędzie bez adnotacji `readOnlyHint`. Opieraj się przede wszystkim na roli IAM. Jeśli dodasz `--read-only`, uruchom `/mcp` i potwierdź, że `call_aws` nadal jest na liście, zanim zaczniesz na nim polegać.

## Podłącz Azure i przypnij stabilne wydanie

Azure MCP Server odpytuje wiele usług Azure i nimi zarządza, korzystając z twojej lokalnej tożsamości Azure. **Tag `latest` w npm to beta**: 26.09.2026 `@azure/mcp@latest` wskazywał `3.0.0-beta.47`, a najnowsze stabilne wydanie to `2.0.5`, przy czym plugin `azure` w `claude-plugins-official` uruchamia `@azure/mcp@latest`. Przypnij stabilną wersję i uruchom ją w trybie tylko do odczytu.

**Claude Code**

```bash
az login
az account set --subscription "SUBSCRIPTION_NAME_OR_ID"
claude mcp add azure -- npx -y @azure/mcp@2.0.5 server start --read-only
```

**Codex**

```bash
az login
codex mcp add azure -- npx -y @azure/mcp@2.0.5 server start --read-only
```

**Cursor**

```json
{
  "mcpServers": {
    "azure": {
      "command": "npx",
      "args": ["-y", "@azure/mcp@2.0.5", "server", "start", "--read-only"]
    }
  }
}
```

Konfiguracja jest identyczna we wszystkich trzech agentach: ten sam pakiet, te same argumenty, ten sam `az login`. Dokumentacja poleceń Azure MCP (`microsoft/mcp`) opisuje jeszcze dwa przełączniki. Domyślny tryb `namespace` wystawia jedno narzędzie na usługę Azure, więc lista narzędzi pozostaje krótka, a `--namespace storage --namespace functionapp` ogranicza serwer do wskazanych usług. Jeśli prompt nie podaje subskrypcji, serwer używa domyślnej subskrypcji Azure CLI (`az account set`) albo `AZURE_SUBSCRIPTION_ID`.

Do dokumentacji Azure służy zdalny serwer Microsoft Learn MCP bez uwierzytelniania: `claude mcp add --transport http microsoft-learn https://learn.microsoft.com/api/mcp`.

**Prompt do skopiowania: publiczne bloby i źle skonfigurowane Function Apps**

```text
Use the azure MCP server (read-only). In the current subscription:
1. List storage accounts that allow public blob access. For each: name, resource group, region, and whether any container is actually public.
2. List Function Apps in resource group "prod-api". For each: runtime stack and version, and app setting NAMES only (never values). Flag any app whose Node.js version differs from the "engines" field in this repo's package.json.
Give me the az CLI command that reproduces each list, and change nothing.
```

Pierwszą odpowiedź sprawdzisz poleceniem `az storage account list --query '[?allowBlobPublicAccess].name' -o tsv`. Poprawka to zmiana w Bicepie lub Terraformie, która przechodzi przez review, a nie przełączenie opcji na żywym koncie.

### Wykryj dryf między Terraformem a żywym Azure

Wykrywanie dryfu pasuje do agenta, bo dowody są konkretne po obu stronach: zadeklarowane zasoby w repozytorium i wdrożone zasoby w Azure.

**Prompt do skopiowania: raport dryfu Terraformu**

```text
Read the Terraform configuration in infrastructure/ (all .tf files). Then use the azure MCP server (read-only) to compare the declared resources in resource group "prod-api" with what is deployed.
Report drift as a markdown table: resource, declared value, live value, and whether Terraform or Azure is probably right.
Include resources that exist in Azure but not in Terraform. Do not change Azure or the .tf files.
If there is no drift, print exactly NO_DRIFT and nothing else.
```

Runner CI nie ma twojej lokalnej konfiguracji MCP, więc zadanie przynosi przypięty serwer ze sobą. Uwierzytelnij runner zmiennymi środowiskowymi Azure Identity service principala z rolą Reader, przekaż mu klucz API samego agenta jako sekret CI (zobacz [agenci headless w CI](/pl/ecosystem/agent-tools/headless-agents-ci/)), uruchamiaj zadanie z gałęzi domyślnej i oznacz je jako nieudane, jeśli raport nie brzmi dokładnie `NO_DRIFT`. Dzięki temu nieudany jest też przebieg, który nie dotarł do Azure.

**Claude Code**

Dodaj do repozytorium `ci/azure-mcp.json`:

```json
{
  "mcpServers": {
    "azure": {
      "command": "npx",
      "args": ["-y", "@azure/mcp@2.0.5", "server", "start", "--read-only"]
    }
  }
}
```

```bash
claude -p "$(cat prompts/azure-drift.md)" \
  --mcp-config ci/azure-mcp.json --strict-mcp-config \
  --allowedTools "mcp__azure__*" "Read" "Glob" "Grep" > drift.md
[ "$(tr -d '[:space:]' < drift.md)" = 'NO_DRIFT' ] || { cat drift.md; exit 1; }
```

`--strict-mcp-config` ładuje wyłącznie serwery z tego pliku. `claude -p` startuje w trybie uprawnień Manual (od v2.1.285 w trybie auto u zewnętrznych dostawców lub z wyłączoną telemetrią), więc to `--allowedTools` pozwala uruchomić narzędzia Azure i odczyt plików.

**Codex**

```bash
codex exec --sandbox read-only \
  -c 'mcp_servers.azure.command="npx"' \
  -c 'mcp_servers.azure.args=["-y","@azure/mcp@2.0.5","server","start","--read-only"]' \
  -o drift.md "$(cat prompts/azure-drift.md)"
[ "$(tr -d '[:space:]' < drift.md)" = 'NO_DRIFT' ] || { cat drift.md; exit 1; }
```

Każde `-c` ustawia jeden klucz `config.toml` na czas tego przebiegu. Piaskownica `read-only` nie pozwala Codeksowi edytować plików; Azure ograniczają `--read-only` serwera i rola RBAC.

**Cursor**

Uruchom prompt w trybie agenta z otwartym katalogiem Terraformu, a potem przejdź z raportu do bloku zasobu i popraw go w tej samej sesji.

## Podłącz Google Cloud przez gcloud MCP

Google oferuje dwie drogi. **gcloud MCP** (`@google-cloud/gcloud-mcp`, npm 0.5.3) opakowuje CLI gcloud w jedno narzędzie, `run_gcloud_command`, i blokuje polecenia, które przyjmują dowolne dane wejściowe albo otwierają sesje interaktywne. README określa go jako wersję preview, „not an officially supported Google product”, a ostatnie wydanie w npm pochodzi z 2026-01-05. Działa z aktywnym kontem gcloud, więc najpierw ustaw impersonację konta usługi z rolą viewer dla wszystkich wywołań gcloud, także tych od agenta:

```bash
# Terminal: applies to all three agents
gcloud config set auth/impersonate_service_account agent-viewer@acme-prod.iam.gserviceaccount.com
```

Trzy instalacje różnią się tylko poleceniem dodania serwera:

**Claude Code**

```bash
claude mcp add gcloud -- npx -y @google-cloud/gcloud-mcp
```

**Codex**

```bash
codex mcp add gcloud -- npx -y @google-cloud/gcloud-mcp
```

**Cursor**

```json
{ "mcpServers": { "gcloud": { "command": "npx", "args": ["-y", "@google-cloud/gcloud-mcp"] } } }
```

Druga droga to **endpointy MCP hostowane przez Google** pod `https://<service>.googleapis.com/mcp`, zarejestrowane w Official MCP Registry dla `compute`, `container` (GKE), `run`, `sqladmin`, `firestore`, `monitoring` i innych. Uwierzytelniają się przez Google OAuth z twoimi uprawnieniami IAM i mogą wymagać własnego klienta OAuth (`claude mcp add --transport http … --client-id …`). Przetestuj taki endpoint we własnym kliencie, zanim wdrożysz go w zespole; do tego czasu używaj gcloud MCP.

Repozytorium `google/skills` (★20.4k) dodaje skille i marketplace pluginów `google-plugins`. Jego plugin `google-cloud-developer` łączy skille o uwierzytelnianiu i bezpiecznym użyciu gcloud z serwerem Developer Knowledge MCP, który wymaga wyeksportowania `DEVELOPERKNOWLEDGE_API_KEY` przed startem agenta:

```bash
claude plugin marketplace add google/skills
claude plugin install google-cloud-developer@google-plugins
```

**Prompt do skopiowania: która rewizja Cloud Run obsługuje ruch**

```text
Use the gcloud MCP server. In project acme-prod, list Cloud Run services in europe-west1.
For each service: the revision serving 100% of traffic, its deploy time, its container image digest, and whether any other revision holds a traffic split.
Read-only: use only list and describe commands. End with the gcloud commands you ran.
```

## Napraw nieudane wdrożenie preview na Vercelu od początku do końca

Zdalny serwer Vercela pod `https://mcp.vercel.com` działa tylko do odczytu w pierwszym wydaniu, według manifestu pluginu Vercela: przeszukuje dokumentację, listuje projekty i wdrożenia oraz czyta logi, czyli robi to, czego potrzebuje nieudany preview. Plugin `vercel` łączy go z 37 skillami i 3 hookami i dodaje do każdej sesji około 4217 tokenów stałego kosztu (`claude plugin details`, Claude Code 2.1.283). Instaluj go na poziomie projektu albo dodaj sam serwer.

**Claude Code**

```bash
claude plugin install vercel@claude-plugins-official --scope project
# or the server alone:
claude mcp add --transport http vercel https://mcp.vercel.com
```

Potem uruchom `/mcp` w sesji i zaloguj się do Vercela.

**Codex**

```bash
codex mcp add vercel --url https://mcp.vercel.com
codex mcp login vercel
```

**Cursor**

```json
{ "mcpServers": { "vercel": { "url": "https://mcp.vercel.com" } } }
```
Cursor uruchamia OAuth przy pierwszym użyciu.

Pętla utrzymuje dostęp agenta przez MCP w trybie tylko do odczytu; zapisy idą przez Vercel CLI albo integrację z Gitem, tak jak u człowieka.

1. **Odczytaj błąd przez MCP.** Agent znajduje ostatni nieudany preview twojej gałęzi i wyciąga istotne linie logu budowania.

   **Prompt do skopiowania: diagnoza nieudanego preview**

   ```text
   Use the vercel MCP server. Find the most recent preview deployment of project "web" for the current git branch that has state ERROR.
   Show the 20 build log lines around the first error, the framework and Node.js version the build used, and which commit it built.
   Then explain the root cause in two sentences and name the file you expect to change. Do not deploy anything.
   ```

2. **Odtwórz błąd lokalnie**, żeby móc udowodnić poprawkę. Pobierz środowisko preview i zbuduj projekt builderem Vercela:

   ```bash
   vercel pull --yes --environment=preview
   vercel build
   ```

   `vercel pull` zapisuje ustawienia projektu i wartości środowiskowe w `.vercel/`, który musi zostać poza Gitem.

3. **Popraw kod i pozwól, żeby rozstrzygnęły bramki jakości.** Agent dodaje test, który nie przechodzi przy starym zachowaniu, i dopiero potem zmienia kod. Sprawdzanie typów, linter i testy muszą przejść lokalnie, zanim cokolwiek trafi dalej.

   **Prompt do skopiowania: poprawka zaczynająca się od czerwonego testu**

   ```text
   Reproduce the build error locally with `vercel build` and confirm the same error text.
   Write a test that fails for the same reason, then fix the code so the test and `vercel build` both pass.
   Run the type check, linter and full test suite. Show me the before and after output of `vercel build`, and stop before deploying.
   ```

4. **Wdróż preview ponownie.** Jeśli projekt wdraża się przez integrację z Gitem, wypchnij gałąź, a Vercel zbuduje nowy preview. W przeciwnym razie wdróż zbudowany i sprawdzony artefakt: `vercel deploy --prebuilt` (bez `--prebuilt` wcześniejszy `vercel build` jest ignorowany). W Claude Code polecenie pluginu `/vercel:deploy` robi to samo z kontrolami wstępnymi i domyślnie wdraża preview.

5. **Sprawdź nowy preview, a nie deklarację agenta.** `vercel inspect <deployment-url> --wait` czeka na koniec budowania, a `vercel inspect <deployment-url> --logs` pokazuje log. Potem uruchom smoke test na adresie preview i dołącz wynik do pull requesta. Recenzent zatwierdza dowody: czerwony test, zielony log budowania i smoke test.

Promocja na produkcję zostaje w twoim pipeline. Kolejność preview, canary i produkcji opisuje strona o [stopniowym wdrażaniu (progressive delivery)](/pl/workflows/ship/progressive-delivery/).

## Podłącz Stripe'a w sandboxie z ograniczonym kluczem

Serwer Stripe'a potrafi tworzyć produkty, ceny, klientów i zwroty, więc może przesuwać pieniądze. Trzymaj go na koncie sandbox lub w trybie testowym. Skill Stripe'a `stripe-best-practices` zaleca osobne sandboxy dla lokalnego developmentu i CI oraz ograniczone klucze API (`rk_…`) z uprawnieniami potrzebnymi tylko do danego zadania.

**Claude Code**

```bash
claude plugin install stripe@claude-plugins-official
```

Plugin łączy się z `https://mcp.stripe.com` przez OAuth i dodaje skille Stripe'a oraz dwa polecenia, `/stripe:explain-error` i `/stripe:test-cards`, za około 2238 tokenów stałego kosztu. Przy autoryzacji wybierz konto sandbox.

**Codex**

Użyj serwera lokalnego z ograniczonym kluczem testowym odczytywanym ze środowiska:

```toml
# ~/.codex/config.toml
[mcp_servers.stripe]
command = "npx"
args = ["-y", "@stripe/mcp@0.3.3"]
env_vars = ["STRIPE_SECRET_KEY"]
```

Przed startem `codex` wyeksportuj `STRIPE_SECRET_KEY` z kluczem `rk_test_…`. Uprawnienia klucza decydują, które narzędzia serwer udostępni.

**Cursor**

```text
/add-plugin stripe
```

Uruchom to w czacie Agent w Cursorze (według README Stripe'a).

**Prompt do skopiowania: cena w trybie testowym i sprawdzony webhook**

```text
Use the stripe MCP server. First retrieve the account balance and confirm livemode is false; stop if it is true.
Create product "Pro" with a 29 USD monthly recurring price. Put the price ID into .env.example as STRIPE_PRICE_PRO (ID only, no keys).
Then check our webhook handler in src/webhooks/stripe.ts handles checkout.session.completed and customer.subscription.updated, and tell me the `stripe trigger` commands that exercise both.
```

Każdy obiekt Stripe'a ma pole `livemode`, więc sprawdzenie trybu jest deterministyczne. Ścieżkę webhooka udowadniają zdarzenia, a nie lektura handlera: `stripe listen --forward-to localhost:3000/webhook` w jednym terminalu i `stripe trigger checkout.session.completed` w drugim, plus test, który sprawdza, co handler zapisał.

## Połącz każdy serwer ze skillami dostawcy i pilnuj kosztu kontekstu

Serwer daje agentowi żywy stan, a skill reguły dostawcy dotyczące działania na tym stanie. Instaluj skille tylko dla platform, na które wdrażasz: README `microsoft/skills` ostrzega, że załadowanie wszystkich skilli „causes context rot”.

| Dostawca | Instalacja skilli | Co dodają |
| --- | --- | --- |
| AWS | W zestawie z `aws-core`; albo `npx skills add aws/agent-toolkit-for-aws/skills` | CDK, CloudFormation, serverless, kontenery, IAM, zarządzanie kosztami, przegląd Well-Architected |
| Azure | `npx skills add microsoft/azure-skills` (albo plugin `azure` po zastąpieniu jego wpisu serwera przypiętym) | `azure-prepare`, `azure-deploy`, `azure-diagnostics`, `azure-validate` |
| SDK Azure | `npx skills add microsoft/skills --full-depth` | 175 skilli SDK; bez `--full-depth` CLI znajduje tylko 13 skilli z katalogu głównego |
| Google Cloud | `npx skills add google/skills --skill gke-basics cloud-run-basics google-cloud-recipe-auth` | Praktyki GKE, Cloud Run i uwierzytelniania |
| Stripe | W zestawie z pluginem `stripe`; albo `npx skills add https://docs.stripe.com` | `stripe-best-practices`, `upgrade-stripe`, `stripe-docs` |
| Vercel | W zestawie z pluginem `vercel` | Wdrożenia, funkcje, zmienne środowiskowe, Vercel CLI |

Wybierz jeden kanał na agenta; plugin i `npx skills add` dla tego samego dostawcy dają duplikaty. `claude plugin details <plugin>` wypisuje stały koszt pluginu w tokenach, ale bez schematów narzędzi MCP, więc uruchom `/context` przed dodaniem serwera i po nim. Koszt obniżają filtr `--namespace` w Azure, pluginy na poziomie projektu (`--scope project`) oraz klucze `enabled_tools` i `disabled_tools` w Codeksie. Więcej na stronach o [najlepszych skillach backendowych i platformowych](/pl/ecosystem/skills/top-skills-backend/) i o [obniżaniu kosztu tokenów MCP](/pl/ecosystem/mcp/reducing-mcp-token-cost/).

## Jak udowodnić, że praca agenta w chmurze jest poprawna?

Sprawdzasz artefakty, które tworzą same platformy, a nie podsumowanie agenta:

- **Każdą inwentaryzację potwierdza deterministyczne zapytanie.** Lista Lambd, publiczne konta storage i rewizje Cloud Run mają swoje polecenie CLI, którego wynik porównujesz z tabelą agenta.
- **Log audytowy pokazuje, co agent wywołał.** Po sesji tylko do odczytu CloudTrail ani activity log Azure nie powinny zawierać żadnych zapisów tożsamości agenta.
- **Zmiany przychodzą jako przejrzany kod.** Aktualizacja runtime'u czy korekta dryfu to pull request z infrastrukturą jako kodem; właściciel platformy zatwierdza `terraform plan` lub `cdk diff`, nie prozę.
- **Wdrożenia weryfikuje się na wdrożonym adresie.** Pętla Vercela kończy się zielonym logiem budowania i smoke testem, dołączonymi do pull requesta jako część [pakietu dowodów](/pl/workflows/ship/evidence-bundle/).
- **Tryb się sprawdza, a nie zakłada.** Praca ze Stripe'em zaczyna się od `livemode` równego false, a ścieżkę webhooka potwierdza `stripe trigger`.
- **Tryb tylko do odczytu testujesz raz.** Poproś agenta o zatrzymanie nieszkodliwego zasobu testowego i potwierdź, że serwer odmawia albo tożsamość dostaje odmowę.

## Co psuje się w serwerach MCP chmury i jak z tego wyjść?

**Narzędzia Azure kończą się błędem uwierzytelniania.** Uruchom `az login`, a potem zrestartuj agenta, żeby serwer wystartował ze świeżymi poświadczeniami. W CI ustaw zmienne środowiskowe Azure Identity dla service principala.

**Agent zwraca zasoby Azure, których nie znasz.** Działa na złej subskrypcji. Uruchom `az account show`, przełącz subskrypcję przez `az account set --subscription "NAME_OR_ID"` albo podaj ją w prompcie.

**Zapytania Azure przekraczają limit czasu na dużej subskrypcji.** Zawęź prompt do jednej grupy zasobów i ogranicz serwer przez `--namespace`.

**Agent nie może zmienić czegoś, co miał zmienić.** To RBAC albo `--read-only` robi swoje. Wprowadź zmianę przez pull request i CI, a nie przez poszerzenie roli agenta.

**Instalacja `…@claude-plugins-official` zgłasza, że nie ma takiego marketplace'u.** Niektóre świeże instalacje Claude Code nie mają skonfigurowanego żadnego marketplace'u. Uruchom `claude plugin marketplace add anthropics/claude-plugins-official` (albo `/plugin marketplace update claude-plugins-official`, jeśli jest na liście, ale nieaktualny) i ponów instalację.

**`call_aws` nie działa, choć wyszukiwanie w dokumentacji działa.** Nie znaleziono poświadczeń AWS. Plugin `aws-core` uruchamia proxy z `--skip-auth`, które przy braku poświadczeń wysyła żądania bez podpisu, więc narzędzia bez uwierzytelniania nadal odpowiadają. Wyeksportuj `AWS_MCP_PROXY_PROFILES` albo `AWS_PROFILE`, odśwież poświadczenia profilu źródłowego, jeśli wygasły (dla IAM Identity Center `aws sso login`), i zrestartuj agenta.

**Serwer AWS długo się nie pojawia.** Pierwsze uruchomienie `uvx` pobiera proxy. Uruchom je raz w terminalu, żeby wypełnić cache, i połącz się ponownie przez `/mcp`.

**gcloud MCP odrzuca polecenie.** Jego lista zakazanych poleceń celowo blokuje polecenia interaktywne i przyjmujące dowolne dane. Poproś o odpowiednik `list` lub `describe` albo uruchom polecenie samodzielnie.

**Vercel MCP pokazuje złe projekty.** OAuth przyznał dostęp do innego zespołu. Wyloguj serwer i autoryzuj go ponownie z właściwym zespołem.

**Serwer Stripe'a działa na złym koncie.** OAuth przyznano dla konta produkcyjnego albo w środowisku jest klucz `sk_live_`. Unieważnij dostęp lub klucz, autoryzuj ponownie na sandboxie i zaczynaj każdą sesję od sprawdzenia `livemode`. Skill Stripe'a zaznacza też, że konto utworzone przez `stripe sandbox create` trzeba przejąć (`stripe sandbox claim`), zanim MCP będzie mogło z niego korzystać.

Ogólne problemy z połączeniem (serwery, które nie startują, pętle OAuth, puste listy narzędzi) opisuje strona o [problemach z połączeniem MCP](/pl/ecosystem/mcp/mcp-connection-issues/).

**Pułapki, które wyglądają dobrze, a są błędne (sprawdzone 26.09.2026)**

- `npx -y @azure/mcp@latest`: wskazuje `3.0.0-beta.47`. Przypnij `@azure/mcp@2.0.5`.
- `@aws/mcp`, `@awslabs/mcp`, `@vercel/mcp`: wszystkie dają 404 w npm. AWS działa przez `uvx mcp-proxy-for-aws-cli`, a Vercel jest wyłącznie zdalny.
- `stripe/agent-toolkit`: adres działa, ale kanoniczne repozytorium to `stripe/ai`.
- `claude mcp add vercel https://mcp.vercel.com` bez `--transport http`: przyjęte bez ostrzeżenia jako serwer stdio, którego poleceniem jest URL; pada przy połączeniu.
- `claude mcp add --url …`: `--url` to flaga Codeksa, nie Claude Code.
- `headers = {…}` we wpisie serwera Codeksa: po cichu ignorowane. Właściwe klucze to `http_headers`, `env_http_headers` i `bearer_token_env_var`.
- Polecenia z `--client-id` dla hostowanych endpointów Google skopiowane z forów: przetestuj je we własnym kliencie, zanim wdrożysz je w zespole.
- `--api-key=sk_...` w linii poleceń: nigdy nie wpisuj klucza. Czytaj `STRIPE_SECRET_KEY` ze środowiska i używaj ograniczonego klucza testowego.

## Dokąd dalej z MCP dla chmury

- [Bezpieczeństwo MCP](/pl/ecosystem/mcp/mcp-security/) — Prompt injection, poświadczenia i dostęp do produkcji dla każdego podłączanego serwera MCP.
- [Serwery MCP dla infrastruktury](/pl/ecosystem/mcp/infrastructure-mcp/) — Serwery Terraform, Kubernetes i Docker dla zmian, które ta strona kieruje przez CI.
- [Serwery MCP Cloudflare](/pl/ecosystem/mcp/cloudflare-mcp/) — Workers, KV, R2 i D1 przez zarządzane serwery Cloudflare.
- [Uprawnienia i piaskownice](/pl/workflows/harness/permissions-and-sandboxing/) — Zdecyduj, co każdy agent może uruchamiać, zanim dotknie konta w chmurze.
- [Wprowadzenie do MCP](/pl/ecosystem/mcp/) — Jak serwery MCP łączą się z każdym agentem i jakie pliki konfiguracji czyta każdy z nich.
