Skip to content

feat: Add ResourceShareAccepter CRD for accepting RAM share invita… - #43

Open
rhysxevans wants to merge 7 commits into
aws-controllers-k8s:mainfrom
rhysxevans:ram_share_acceptor
Open

feat: Add ResourceShareAccepter CRD for accepting RAM share invita…#43
rhysxevans wants to merge 7 commits into
aws-controllers-k8s:mainfrom
rhysxevans:ram_share_acceptor

Conversation

@rhysxevans

@rhysxevans rhysxevans commented Feb 15, 2026

Copy link
Copy Markdown

Adds a ResourceShareInvitation CRD that lets a receiver account accept incoming AWS RAM share invitations declaratively, addressing aws-controllers-k8s/community#2786.

Per the reviewer feedback in #43 (comment), this PR has been reworked to use the standard ACK code-generation model rather than a hand-written resource manager.

Approach

Follows the same pattern route53resolver-controller#65 used for ResolverRuleAssociation: pick the noun the AWS API returns (rather than a verb), and map AWS lifecycle operations to ACK's Create/Read/Delete via generator.yaml.

  • Kind: ResourceShareInvitation — matches the AWS API entity returned by GetResourceShareInvitations / AcceptResourceShareInvitation.
  • Spec: the user provides resourceShareInvitationARN directly.
  • Lifecycle:
    • Create → AcceptResourceShareInvitation
    • Read → GetResourceShareInvitations (filtered by the spec ARN)
    • Delete → DisassociateResourceShare
  • Synced when: Status.Status == ACCEPTED.

Hand-written surface area

Everything else is generated. The only hand-written inputs are:

  • generator.yaml: operation → resource mapping, field annotations (primary key / immutable / required, print columns), terminal_codes, 404 mapping (ResourceShareInvitationArnNotFoundException), synced.when.
  • templates/hooks/resource_share_invitation/sdk_read_many_post_build_request.go.tpl: filters GetResourceShareInvitations by the spec ARN.
  • templates/hooks/resource_share_invitation/sdk_delete_post_build_request.go.tpl: sets Principals from Status.ReceiverAccountID for DisassociateResourceShare.

Testing

  • go build ./... and go test ./... pass.
  • Generated artifacts produced via make build-controller SERVICE=ram + scripts/build-controller-release.sh ram against code-generator v0.59.1-7-g2970ca9 (same code-generator commit currently used by route53resolver-controller).
  • E2E test reworked to use the new Kind and spec field; a malformed-ARN test exercises the terminal-error path via MalformedArnException.

Issue #, if available: aws-controllers-k8s/community#2786

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

@ack-prow
ack-prow Bot requested review from a-hilaly and michaelhtm February 15, 2026 18:51
@ack-prow ack-prow Bot added the needs-ok-to-test Indicates a PR that requires an org member to verify it is safe to test. label Feb 15, 2026
@ack-prow

ack-prow Bot commented Feb 15, 2026

Copy link
Copy Markdown

Hi @rhysxevans. Thanks for your PR.

I'm waiting for a aws-controllers-k8s member to verify that this patch is reasonable to test. If it is, they should reply with /ok-to-test on its own line. Until that is done, I will not automatically test new commits in this PR, but the usual testing commands by org members will still work. Regular contributors should join the org to skip this step.

Once the patch is verified, the new status will be reflected by the ok-to-test label.

I understand the commands that are listed here.

Details

Instructions for interacting with me using PR comments are available here. If you have questions or suggestions related to my behavior, please file an issue against the kubernetes/test-infra repository.

@michaelhtm michaelhtm left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for the contribution @rhysxevans
Should we consider making ResourceShareAccepter a functionality of the ResourceShare CRD?
Similar to what we do with EKS AccessPolicies

@rhysxevans

Copy link
Copy Markdown
Author

Hi

Thanks for reviewing, I am ultimately happy to take direction from you.

I do however feel that there may be a subtle difference

  1. AccessPolicies are attached to AccessEntries, in the same account.
  2. ResourceShare's are created in one account and shared to another (assuming not in the same org), and the ResourceShareAccepter is done in the "other" account. This is particularly relevant where the "sharer" is a 3rd party saas provider.

I don't know if my interpretation is in any way relevant though.

Let me know your thoughts

Thanks

rhysxevans added a commit to rhysxevans/ram-controller that referenced this pull request Feb 17, 2026
This commit integrates resource share invitation acceptance functionality
into the existing ResourceShare CRD, enabling dual-mode operation for
cross-account AWS RAM sharing scenarios.

## Key Changes

### 1. Dual-Mode ResourceShare CRD
- Added acceptInvitation field to enable Accept Mode
- Made name field optional (required in Create Mode, not needed in Accept Mode)
- Added invitation-specific status fields (invitationARN, invitationStatus, etc.)
- Added resources field to status for tracking shared resources

### 2. Accept Mode Implementation
- Implemented sdkAcceptInvitation() for accepting pending invitations
- Implemented sdkFindAcceptedInvitation() for finding existing accepted invitations
- Modified sdkCreate() to route to acceptance logic when acceptInvitation is set
- Modified sdkFind() to route to invitation lookup in Accept Mode
- Added validation to ensure name is provided in Create Mode

### 3. Deletion Handling
- Implemented sdkRejectOrLeaveShare() for proper cleanup in Accept Mode
- PENDING invitations: Rejected using RejectResourceShareInvitation
- ACCEPTED invitations: Left using DisassociateResourceShare
- Added graceful handling for OperationNotPermittedException (some resource
  types like Network Firewall don't support self-disassociation)

### 4. Deprecated API Replacement
- Removed usage of deprecated ResourceShareAssociations field
- Implemented populateInvitationResources() using ListPendingInvitationResources API
- Added logging and metrics for resource population
- Handles invitations with no resources gracefully

### 5. Documentation
- Added comprehensive function-level documentation for Accept Mode
- Documented AWS resource type limitations (Network Firewall, etc.)
- Explained deletion behavior and OperationNotPermittedException handling
- Added inline comments for error handling logic

### 6. E2E Tests
- Created test_resource_share_accept_mode.py with Accept Mode tests
- Added test for name validation in Create Mode
- Added test templates for Accept Mode scenarios
- Updated ram_resource_share.py with invitation helper functions

### 7. Examples
- Added resource-share-integrated-modes.yaml with usage examples
- Documented Create Mode and Accept Mode workflows
- Included cross-account sharing examples

## Testing
- ✅ Accept invitation with resources (Network Firewall)
- ✅ Resources populated in status using new API
- ✅ Deletion with OperationNotPermittedException handling
- ✅ Name validation in Create Mode
- ✅ All status fields populated correctly

## AWS Limitations Handled
Some AWS resource types (e.g., Network Firewall) do not support self-disassociation.
For these resources, the Kubernetes resource is deleted successfully, but the AWS
invitation remains ACCEPTED until the share owner removes the principal. This is
expected AWS behavior and is handled gracefully with appropriate logging.

Addresses reviewer feedback on PR aws-controllers-k8s#43 regarding integrated vs separate CRD approach.
@rhysxevans

Copy link
Copy Markdown
Author

FYI: @michaelhtm I have created #44 as a response to your comment #43 (review)

@michaelhtm

Copy link
Copy Markdown
Member
  1. AccessPolicies are attached to AccessEntries, in the same account.
  2. ResourceShare's are created in one account and shared to another (assuming not in the same org), and the ResourceShareAccepter is done in the "other" account. This is particularly relevant where the "sharer" is a 3rd party saas provider.

You are right, thanks for clarifying the differences.
After a closer look, i do see the need for an accepter, but i wonder if ACK is equipped to support this.
I noticed you have not used the code-generator.

Another quirk i see is, an Accepter is not necessarily a resource, so it feels weird to have a CRD for it, although i do see Terraform does support it

@a-hilaly @knottnt any thoughts?

@rhysxevans

Copy link
Copy Markdown
Author

Hi, yep, apologies around not using the code generator.

Once we have a direction of travel, I will look at re-implementing via the code generator

@rhysxevans

Copy link
Copy Markdown
Author

Hi

@michaelhtm @a-hilaly @knottnt any thoughts ?

@michaelhtm

Copy link
Copy Markdown
Member

Hey @rhysxevans
All ACK controllers are generated by code-generator. This one seems like it wasn't. Can you try using generator.yaml to introduce the resource? You can use this PR as an example: aws-controllers-k8s/route53resolver-controller#65

@rhysxevans

Copy link
Copy Markdown
Author

Hi @michaelhtm

Can you confirm which way you would like to go with the CRD. the way outlined in this PR (separate) or in the current CRD #44 ?

I can then look at the the code generator for the relevant solution ?

Thanks

@ack-prow

ack-prow Bot commented Jun 20, 2026

Copy link
Copy Markdown

[APPROVALNOTIFIER] This PR is NOT APPROVED

This pull-request has been approved by: rhysxevans
Once this PR has been reviewed and has the lgtm label, please assign a-hilaly for approval. For more information see the Code Review Process.

The full list of commands accepted by this bot can be found here.

Details Needs approval from an approver in each of these files:

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

rhysxevans added a commit to rhysxevans/ram-controller that referenced this pull request Jun 20, 2026
Replaces the hand-written ResourceShareAccepter implementation with the
standard ACK code-generation model, addressing reviewer feedback on aws-controllers-k8s#43.

Naming: renamed from ResourceShareAccepter (verb) to
ResourceShareInvitation (noun), matching the AWS API entity returned by
GetResourceShareInvitations / AcceptResourceShareInvitation. This follows
the same convention route53resolver-controller used for
ResolverRuleAssociation.

UX: the user provides spec.resourceShareInvitationARN directly. The
controller calls AcceptResourceShareInvitation on Create,
GetResourceShareInvitations on Read, and DisassociateResourceShare on
Delete.

generator.yaml:
- operations: AcceptResourceShareInvitation (Create),
  GetResourceShareInvitations (Read_Many),
  DisassociateResourceShare (Delete)
- ResourceShareInvitationArn: primary key, immutable, required
- Status and ResourceShareArn: read-only with print columns
- synced.when: Status.Status == ACCEPTED
- terminal_codes: MalformedArn, AlreadyAccepted, AlreadyRejected, Expired
- 404 mapping: ResourceShareInvitationArnNotFoundException

templates/hooks/resource_share_invitation/:
- sdk_read_many_post_build_request: filter list by spec ARN
- sdk_delete_post_build_request: set Principals from
  Status.ReceiverAccountID

E2E tests renamed to *_resource_share_invitation. The "no pending
invitation" test is replaced with a "malformed ARN terminal" test, which
exercises the terminal-error path under the new model via
MalformedArnException.

By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache 2.0 license.
@rhysxevans

Copy link
Copy Markdown
Author

In

apiVersion: ram.services.k8s.aws/v1alpha1
kind: ResourceShareInvitation
metadata:
  name: test-ack
  namespace: default
spec:
  resourceShareInvitationARN: arn:aws:ram:eu-west-1:512345678910:resource-share-invitation/e014ac15-6db0-4bac-8545-6aase8db915cc

Out

apiVersion: ram.services.k8s.aws/v1alpha1
kind: ResourceShareInvitation
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"ram.services.k8s.aws/v1alpha1","kind":"ResourceShareInvitation","metadata":{"annotations":{},"name":"test-ack","namespace":"default"},"spec":{"resourceShareInvitationARN":"arn:aws:ram:eu-west-1:512345678910:resource-share-invitation/e014ac15-6db0-4bac-8545-6aase8db915cc"}}
  creationTimestamp: "2026-06-20T09:44:05Z"
  finalizers:
  - finalizers.ram.services.k8s.aws/ResourceShareInvitation
  generation: 1
  name: test-ack
  namespace: default
  resourceVersion: "2277"
  uid: f94f923c-618c-4802-8cd9-c49b9cae26bf
spec:
  resourceShareInvitationARN: arn:aws:ram:eu-west-1:512345678910:resource-share-invitation/e014ac15-6db0-4bac-8545-6aase8db915cc
status:
  ackResourceMetadata:
    arn: arn:aws:ram:eu-west-1:512345678910:resource-share-invitation/e014ac15-6db0-4bac-8545-6aase8db915cc
    ownerAccountID: "00012345678910"
    partition: aws
    region: eu-west-1
  conditions:
  - lastTransitionTime: "2026-06-20T09:54:28Z"
    message: Resource synced successfully
    reason: ""
    status: "True"
    type: ACK.ResourceSynced
  - lastTransitionTime: "2026-06-20T09:54:28Z"
    message: Resource synced successfully
    reason: ""
    status: "True"
    type: Ready
  invitationTimestamp: "2026-06-20T09:54:28Z"
  receiverAccountID: "00012345678910"
  resourceShareARN: arn:aws:ram:eu-west-1:512345678910:resource-share/e014ac15-6db0-4bac-8545-6aase8db915cc
  resourceShareName: test-ack
  senderAccountID: "512345678910"
  status: ACCEPTED

   Implements a custom ACK resource to accept AWS RAM (Resource Access Manager)
   share invitations. This addresses the limitation that the generated controller
   only supports creating outgoing shares, not accepting incoming invitations.
   Implementation details:
   - Created ResourceShareAccepter CRD following Terraform's aws_ram_resource_share_accepter pattern
   - Maps non-standard AWS RAM operations to Kubernetes resource lifecycle:
     * Create: Find pending invitation by ShareARN and accept it
     * Read: Get invitation status from AWS
     * Update: No-op (invitations are immutable)
     * Delete: Disassociate from the share (leave it)
   - Implements full ACK resource manager interface with custom SDK operations
   - Uses finalizer-based resource management for proper lifecycle handling
   - Includes Helm chart integration for easy deployment
   New CRD: ResourceShareAccepter (ram.services.k8s.aws/v1alpha1)
   Spec:
     - shareARN: ARN of the resource share to accept
   Status:
     - invitationARN: ARN of the accepted invitation
     - invitationStatus: Current status (PENDING, ACCEPTED, REJECTED, EXPIRED)
     - senderAccountID: Account that sent the invitation
     - receiverAccountID: Account receiving the invitation
     - shareName: Name of the resource share
   Files changed:
   - apis/v1alpha1/resource_share_invitation.go: CRD type definitions
   - pkg/resource/resource_share_invitation/: Complete resource implementation
   - config/crd/bases/ram.services.k8s.aws_resourceshareaccepters.yaml: Generated CRD
   - helm/crds/ram.services.k8s.aws_resourceshareaccepters.yaml: Helm CRD
   - cmd/controller/main.go: Register ResourceShareAccepter resource
   - helm/values.yaml: Add ResourceShareAccepter to reconcile resources
   - config/crd/kustomization.yaml: Include new CRD in kustomization
   Testing:
   - Verified controller builds successfully
   - Tested locally with AWS profile authentication
   - Confirmed resource reconciliation and error handling
   - Validated CRD generation and Helm integration
…eAccepter

   This commit fixes two critical issues with the ResourceShareAccepter controller:
   1. Terminal Error Handling
      - Wrap "no pending invitation" error with ackerr.NewTerminalError() to prevent
        infinite retry loops when no invitation exists
      - Add updateConditions() method to properly detect and handle Terminal/Recoverable errors
      - Add terminalAWSError() method to identify AWS errors that should be terminal
        (e.g., MalformedArnException)
      - Update onError() in manager.go to call updateConditions() and return ackerr.Terminal
        when Terminal condition is set
   2. Status Population
      - Add setStatusDefaults() method to initialize resource status metadata
      - Call setStatusDefaults() in sdkCreate() before setting invitation-specific fields
      - Call setStatusDefaults() in sdkFind() before processing invitations
      - Ensures ackResourceMetadata (region, ownerAccountID, ARN) and conditions array
        are properly initialized
   3. Test Infrastructure
      - Add e2e integration test for ResourceShareAccepter
      - Test validates Terminal condition is set when no pending invitation exists
      - Add helper functions for working with RAM share invitations
      - Add test documentation and resource templates
   Changes to pkg/resource/resource_share_invitation/sdk.go:
   - Import corev1 for condition handling
   - Wrap "no pending invitation" error with ackerr.NewTerminalError() (line 127)
   - Add setStatusDefaults() method (lines 254-267)
   - Add updateConditions() method (lines 270-346)
   - Add terminalAWSError() method (lines 349-364)
   - Call setStatusDefaults() in sdkFind() (line 72)
   - Call setStatusDefaults() in sdkCreate() (line 147)
   Changes to pkg/resource/resource_share_invitation/manager.go:
   - Import ackerr package
   - Replace onError() method to properly handle Terminal conditions (lines 185-207)
   Test files added:
   - test/e2e/tests/test_resource_share_accepter.py
   - test/e2e/ram_resource_share_accepter.py
   - test/e2e/resources/ram_resource_share_accepter.yaml
   - test/e2e/README.md
   Fixes:
   - Controller no longer retries indefinitely when no invitation exists
   - Kubernetes resource status is now fully populated with all fields
   - Terminal errors are properly detected and stop reconciliation
   - Integration tests validate expected behavior
Replaces the hand-written ResourceShareAccepter implementation with the
standard ACK code-generation model, addressing reviewer feedback on aws-controllers-k8s#43.

Naming: renamed from ResourceShareAccepter (verb) to
ResourceShareInvitation (noun), matching the AWS API entity returned by
GetResourceShareInvitations / AcceptResourceShareInvitation. This follows
the same convention route53resolver-controller used for
ResolverRuleAssociation.

UX: the user provides spec.resourceShareInvitationARN directly. The
controller calls AcceptResourceShareInvitation on Create,
GetResourceShareInvitations on Read, and DisassociateResourceShare on
Delete.

generator.yaml:
- operations: AcceptResourceShareInvitation (Create),
  GetResourceShareInvitations (Read_Many),
  DisassociateResourceShare (Delete)
- ResourceShareInvitationArn: primary key, immutable, required
- Status and ResourceShareArn: read-only with print columns
- synced.when: Status.Status == ACCEPTED
- terminal_codes: MalformedArn, AlreadyAccepted, AlreadyRejected, Expired
- 404 mapping: ResourceShareInvitationArnNotFoundException

templates/hooks/resource_share_invitation/:
- sdk_read_many_post_build_request: filter list by spec ARN
- sdk_delete_post_build_request: set Principals from
  Status.ReceiverAccountID

E2E tests renamed to *_resource_share_invitation. The "no pending
invitation" test is replaced with a "malformed ARN terminal" test, which
exercises the terminal-error path under the new model via
MalformedArnException.

By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache 2.0 license.
Add two hooks needed to make the Create (Accept) lifecycle work end
to end against the real RAM API:

- sdk_create_post_build_request: populate AcceptResourceShareInvitation
  input from Spec.ResourceShareInvitationARN. The field is marked
  is_primary_key so the generator otherwise reads it from
  Status.ACKResourceMetadata.ARN, which is empty on first Create.

- sdk_read_many_post_set_output: return NotFound when the invitation
  status is PENDING, so the runtime invokes sdkCreate and accepts the
  invitation rather than treating it as already-existing.

Validated live against a real cross-account invitation: Apply ->
AcceptResourceShareInvitation succeeds, status flips to ACCEPTED;
Delete -> DisassociateResourceShare succeeds and AWS confirms the
receiver is no longer associated.
AWS purges accepted invitations from GetResourceShareInvitations after a
retention window (7 days for most resource types, 12 hours for some).
After that the call returns an empty list even though the account is
still associated with the share. The runtime would then treat the
resource as not-yet-created and call AcceptResourceShareInvitation again,
which fails terminally with ResourceShareInvitationAlreadyAcceptedException
and flips a healthy resource into a permanent Terminal condition.

Add a sdk_read_many_post_request hook that, when the invitation list is
empty but the share ARN was previously recorded, confirms the association
still exists via GetResourceShares(OTHER-ACCOUNTS) and reports the
resource as still ACCEPTED. If the share is no longer returned (genuine
disassociation) the read falls through to NotFound as before.
Deleting a ResourceShareInvitation custom resource calls
DisassociateResourceShare, which detaches the receiver account from the
share and revokes access to all shared resources. Add a documentation.yaml
override that appends a WARNING to the resourceShareInvitationARN field so
the caveat surfaces in the generated Go type, the CRD description, and
kubectl explain. Regenerate the affected API type and CRD.
The invitation ARN was both a user-supplied desired-state input and the
resource's primary key. That conflation is fragile: the invitation ARN is
purged ~7 days after acceptance, so the designated identity disappears and
adoption keyed on it cannot resolve.

Move is_primary_key from ResourceShareInvitationArn to the read-only
ResourceShareArn, which is service-assigned from the accept response and
remains resolvable via GetResourceShares after the invitation is purged.
The invitation ARN stays a required, immutable spec input. Adoption and
SetIdentifiers now key on resourceShareARN. Regenerate the affected code.
@rhysxevans
rhysxevans force-pushed the ram_share_acceptor branch from a7abc91 to 2965b9b Compare June 27, 2026 09:41
@HansG89

HansG89 commented Aug 4, 2026

Copy link
Copy Markdown

Hi, just checking in on this one. Is it still actively being worked on, or blocked on something? We have a use case waiting on this and would be happy to help move it forward if useful. Thanks for the work here!

@michaelhtm

Copy link
Copy Markdown
Member

Hey @HansG89 @rhysxevans
I don't think this is a CRD we can support in ACK.
ACK manages control plane resources. AcceptResourceShare feels more like a Dataplane operation (no resource is being created).
cc: @knottnt @a-hilaly

@HansG89

HansG89 commented Aug 5, 2026

Copy link
Copy Markdown

Hi @michaelhtm

appreciate you taking another look at this.

Genuinely curious about the control-plane/dataplane distinction here, since route53resolver-controller ships two CRDs that look like the same shape as what's being proposed here: pure association/action resources with no independent AWS-native existence beyond the link itself.

From route53resolver-controller's generator.yaml (currently on main, not in ignore.resource_names):

operations:
  AssociateResolverRule:
    resource_name: ResolverRuleAssociation
    operation_type: Create
  DisassociateResolverRule:
    resource_name: ResolverRuleAssociation
    operation_type: Delete
  GetResolverRuleAssociation:
    resource_name: ResolverRuleAssociation
    operation_type: Read_One

ResolverRuleAssociation and ResolverQueryLogConfigAssociation are both live, shipped CRDs today, both modeling an associate/disassociate action rather than a resource with its own lifecycle independent of the association.

This is actually the exact pattern you pointed @rhysxevans toward back in June (route53resolver-controller#65) as the model to follow for this PR. Given that, would love to understand what makes AcceptResourceShareInvitation different enough to be dataplane while AssociateResolverRule counts as control-plane. Is it about mutability of existing state vs. creating a new association record, or something else? Happy to help narrow the distinction if there's a principle here that should also apply back to the Resolver associations.

@rhysxevans

Copy link
Copy Markdown
Author

Hi, I have found another area where this sort of logic applies, account OU moves, https://docs.aws.amazon.com/cli/latest/reference/organizations/move-account.html, so it would be good to get some guidance.

@HansG89

HansG89 commented Aug 19, 2026

Copy link
Copy Markdown

@a-hilaly @knottnt @michaelhtm, pinging directly for a decision on the CRD shape here. This has been open since February and stalled since the last exchange.

On the "dataplane operation" concern: route53resolver-controller ships two CRDs today that are structurally identical to what's proposed in this PR: an associate/disassociate action modeled as a CRD, with no independent resource lifecycle beyond the action itself.

# route53resolver-controller/generator.yaml (main, merged via #65)
AssociateResolverRule:
  resource_name: ResolverRuleAssociation
  operation_type: Create
DisassociateResolverRule:
  resource_name: ResolverRuleAssociation
  operation_type: Delete
GetResolverRuleAssociation:
  resource_name: ResolverRuleAssociation
  operation_type: Read_One

Same for ResolverQueryLogConfigAssociation (AssociateResolverQueryLogConfig / DisassociateResolverQueryLogConfig). Both are live, generated via generator.yaml, no hand rolled resource manager, same pattern this PR now follows (per @michaelhtm's June 4 suggestion to model it after route53resolver-controller#65).

If AcceptResourceShareInvitation is dataplane because "no resource is created," the same argument applies to AssociateResolverRule. It doesn't create a new AWS side entity either, it links two existing ones. I'd like to understand the distinguishing principle, since as is the two look like the same shape to me, and I want to apply whatever the answer is consistently rather than relitigate it later.

@rhysxevans also flagged a second case with the same shape: organizations:MoveAccount. No CRD exists for it in organizations-controller today, but it's another AWS API that's a pure state transition with no independent resource, worth keeping in mind if a general principle comes out of this discussion.

Could we get a direct yes or no on whether a standalone ResourceShareInvitation CRD (this PR) is acceptable, given the Resolver precedent above? And if the answer is no, rather than let this stall again, I'd propose adding the accept invitation capability as a field on the existing ResourceShare CRD instead (sketched in #44) as a fallback, happy to help drive that if it's the preferred direction. Either way, an explicit decision here unblocks a real use case waiting on this.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

needs-ok-to-test Indicates a PR that requires an org member to verify it is safe to test.

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants