Repokid

Repokid verwendet den Access Advisor von Aardvark, um Berechtigungen zu entfernen, die Zugriff auf ungenutzte Dienste gewähren, und zwar aus den Inline-Richtlinien von IAM-Rollen in einem AWS-Konto.

Erste Schritte

Installation

mkvirtualenv repokid
git clone [email protected]:Netflix/repokid.git
cd repokid
pip install -e .
repokid config config.json

DynamoDB

Sie benötigen eine DynamoDB-Tabelle namens repokid_roles (geben Sie Konto und Endpunkt im dynamo_db-Abschnitt der Konfigurationsdatei an).

Die Tabelle sollte folgende Eigenschaften haben:

• RoleId (string) als primären Partitionsschlüssel, ohne primären Sortierschlüssel
• Einen globalen Sekundärindex namens Account mit einem primären Partitionsschlüssel von Account und RoleId und Account als projizierte Attribute
• Einen globalen Sekundärindex namens RoleName mit einem primären Partitionsschlüssel von RoleName und RoleId und RoleName als projizierte Attribute

Für die Entwicklung können Sie DynamoDB lokal ausführen.

Für den lokalen Betrieb:

docker-compose up

Der Endpunkt für DynamoDB ist http://localhost:8000. Ein Administrationspanel für DynamoDB finden Sie unter http://localhost:8001.

Wenn Sie die Entwicklungsversion ausführen, werden die Tabelle und der Index automatisch für Sie erstellt.

IAM-Berechtigungen

Repokid benötigt eine IAM-Rolle in jedem Konto, das abgefragt wird. Zusätzlich muss Repokid mit einer Rolle oder einem Benutzer gestartet werden, die/das sts:AssumeRole in die verschiedenen Kontorollen aufrufen kann.

RepokidInstanceProfile:

• Nur eines erstellen.
• Muss die Fähigkeit besitzen, sts:AssumeRole in alle RepokidRoles aufzurufen.
• DynamoDB-Berechtigungen für die Tabelle repokid_roles und alle Indizes (angegeben im Unterabschnitt assume_role von dynamo_db in der Konfigurationsdatei) sowie die Fähigkeit, dynamodb:ListTables auszuführen.

RepokidRole:

• Muss in jedem Konto vorhanden sein, das von Repokid verwaltet wird.
• Muss eine Vertrauensrichtlinie haben, die RepokidInstanceProfile erlaubt.
• Der Name muss in connection_iam in der Konfigurationsdatei angegeben werden.
• Hat diese Berechtigungen:

{
 "Version": "2012-10-17",
 "Statement": [
   {
     "Action": [
       "iam:DeleteInstanceProfile",
       "iam:DeleteRole",
       "iam:DeleteRolePolicy",
       "iam:GetAccountAuthorizationDetails",
       "iam:GetInstanceProfile",
       "iam:GetRole",
       "iam:GetRolePolicy",
       "iam:ListInstanceProfiles",
       "iam:ListInstanceProfilesForRole",
       "iam:ListRolePolicies",
       "iam:PutRolePolicy",
       "iam:UpdateRoleDescription"
     ],
     "Effect": "Allow",
     "Resource": "*"
   }
 ]
}

Wenn Sie also n Konten überwachen, benötigen Sie immer n+1 Rollen (n RepokidRoles und 1 RepokidInstanceProfile).

Bearbeiten der config.json

Das Ausführen von repokid config config.json erstellt eine Datei, die Sie bearbeiten müssen. Suchen und aktualisieren Sie folgende Felder:

• dynamodb: Wenn Sie DynamoDB lokal verwenden, setzen Sie den Endpunkt auf http://localhost:8010. Wenn Sie AWS-gehostetes DynamoDB verwenden, setzen Sie region, assume_role und account_number.
• aardvark_api_location: Der Speicherort Ihrer Aardvark-REST-API. Etwa https://aardvark.yourcompany.net/api/1/advisors
• connection_iam: Setzen Sie assume_role auf RepokidRole oder wie auch immer Sie es genannt haben.

Optionale Konfiguration

Repokid verwendet Filter, um zu entscheiden, welche Rollen für das Repoen in Frage kommen. Filter können wie unten beschrieben an Ihre Umgebung angepasst werden.

Blocklist-Filter

Rollen können ausgeschlossen werden, indem sie dem Blocklist-Filter hinzugefügt werden. Ein häufiger Grund, eine Rolle auszuschließen, ist, wenn die entsprechende Arbeitslast gelegentlich Aktionen durchführt, die möglicherweise nicht beobachtet wurden, aber bekanntermaßen erforderlich sind. Es gibt zwei Möglichkeiten, eine Rolle auszuschließen:

• Rollennamen für alle Konten ausschließen: Fügen Sie ihn einer Liste im Konfigurationsabschnitt filter_config.BlocklistFilter.all hinzu.
• Rollennamen für ein bestimmtes Konto ausschließen: Fügen Sie ihn einer Liste im Konfigurationsabschnitt filter_config.BlocklistFilter.<ACCOUNT_NUMBER> hinzu.

Blocklists können auch in einer S3-Blocklist-Datei gepflegt werden. Sie sollten folgendes Format haben:

{
  "arns": ["arn1", "arn2"],
  "names": {"role_name_1": ["all", "account_number_1"], "role_name_2": ["account_number_2", "account_number_3"]}
}

Exklusiv-Filter

Wenn Sie lieber nur bestimmte Rollen repo-en möchten, können Sie den Exklusiv-Filter verwenden. Vielleicht möchten Sie nur Rollen berücksichtigen, die in der Produktion oder von bestimmten Teams verwendet werden. Um Rollen zum Repoen auszuwählen, können Sie deren Namen in der Konfigurationsdatei auflisten. Shell-ähnliche Glob-Muster werden ebenfalls unterstützt. Die Rollenauswahl kann pro Konto oder global festgelegt werden. Um diesen Filter zu aktivieren, setzen Sie "repokid.filters.exclusive:ExclusiveFilter" im Abschnitt active_filters der Konfigurationsdatei. Zur Konfiguration können Sie mit der automatisch generierten Konfigurationsdatei beginnen, die im Abschnitt "filter_config" eine Beispielkonfiguration enthält:

"ExclusiveFilter": {
                   "all": [
                     "<GLOB_PATTERN>"
                     ],
                   "<ACCOUNT_NUMBER>": [
                     "<GLOB_PATTERN>"
                    ]
                   }

Altersfilter

Standardmäßig schließt der Altersfilter Rollen aus, die jünger als 90 Tage sind. Um dies zu ändern, bearbeiten Sie die Konfigurationseinstellung: filter_config.AgeFilter.minimum_age.

Aktive Filter

Neue Filter können erstellt werden, um interne Logik zu unterstützen. Bei Netflix haben wir mehrere, die für unsere Anwendungsfälle spezifisch sind. Um sie zu aktivieren, stellen Sie sicher, dass sie sich im Python-Pfad befinden, und fügen Sie sie im Konfigurationsabschnitt active_filters zur Liste hinzu.

Erweiterung von Repokid

Hooks

Repokid ist über Hooks erweiterbar, die vor, während und nach verschiedenen Operationen aufgerufen werden, wie unten aufgeführt.

Hooks müssen folgendem Interface entsprechen:

from repokid.hooks import implements_hook
from repokid.types import RepokidHookInput, RepokidHookOutput

@implements_hook("TARGET_HOOK_NAME", 1)
def custom_hook(input_dict: RepokidHookInput) -> RepokidHookOutput:
    """Hook-Funktionen werden mit einem Dict aufgerufen, das die oben basierend auf dem Ziel-Hook aufgeführten Schlüssel enthält.
    Alle Mutationen, die an der Eingabe vorgenommen und in der Ausgabe zurückgegeben werden, werden an nachfolgende Hook-Funktionen weitergegeben.
    """
    ...

Beispiele für Hook-Implementierungen finden Sie in repokid.hooks.loggers.

Filter

Benutzerdefinierte Filter können geschrieben werden, um Rollen vom Repoen auszuschließen. Filter müssen folgendem Interface entsprechen:

from repokid.filters import Filter
from repokid.types import RepokidFilterConfig
from repokid.role import RoleList


class CustomFilterName(Filter):
    def __init__(self, config: RepokidFilterConfig = None) -> None:
        """Filter werden mit einem Dict initialisiert, das den Inhalt von `filter_config.FilterName`
        aus der Konfigurationsdatei enthält. Dieses Beispiel würde mit `filter_config.CustomFilterName` initialisiert.
        Auf die Konfiguration kann über `self.config` zugegriffen werden.

        Wenn Sie keine benutzerdefinierte Initialisierungslogik benötigen, können Sie diese Funktion in Ihrer
        Filter-Klasse weglassen.
        """
        super().__init__(config=config)
        # benutzerdefinierte Initialisierungslogik hier
        ...

    def apply(self, input_list: RoleList) -> RoleList:
        """Bestimmen Sie auszuschließende Rollen und geben Sie sie als RoleList zurück"""
        ...

Eine einfache Filterimplementierung finden Sie in repokid.filters.age. Ein komplexeres Beispiel in repokid.blocklist.age.

Verwendung

Sobald Repokid konfiguriert ist, verwenden Sie es wie folgt:

Standardablauf

• Rollen-Cache aktualisieren: repokid update_role_cache <ACCOUNT_NUMBER>
• Rollen-Cache anzeigen: repokid display_role_cache <ACCOUNT_NUMBER>
• Informationen zu einer bestimmten Rolle anzeigen: repokid display_role <ACCOUNT_NUMBER> <ROLE_NAME>
• Eine bestimmte Rolle repoen: repokid repo_role <ACCOUNT_NUMBER> <ROLE_NAME>
• Alle Rollen in einem Konto repoen: repokid repo_all_roles <ACCOUNT_NUMBER> -c

Planung

Anstatt sofort ein Repo auszuführen, können Sie eines planen (schedule_repo-Befehl). Die Dauer zwischen Planung und Berechtigung ist konfigurierbar, aber standardmäßig können Rollen 7 Tage nach der Planung repod werden. Sie können dann einen Befehl repo_scheduled_roles ausführen, um nur Rollen zu repoen, die bereits geplant wurden.

Gezieltes Entfernen einer bestimmten Berechtigung

Angenommen, Sie finden eine bestimmte Berechtigung in Ihrer Umgebung besonders gefährlich. Hier verwende ich s3:PutObjectACL als Beispiel. Sie können Repokid verwenden, um alle Rollen zu finden, die diese Berechtigung haben (auch solche, die in einem Wildcard versteckt sind), und dann nur diese einzelne Berechtigung zu entfernen.

Suchen und Entfernen:

• Stellen Sie sicher, dass der Rollen-Cache vor Beginn aktualisiert ist.
• Rollen mit einer bestimmten Berechtigung suchen: repokid find_roles_with_permissions <permission>... [--output=ROLE_FILE]
• Berechtigung von Rollen entfernen: repokid remove_permissions_from_roles --role-file=ROLE_FILE <permission>... [-c]

Beispiel:

$ repokid find_roles_with_permissions "s3:putobjectacl" "sts:assumerole" --output=myroles.json
...
$ repokid remove_permissions_from_roles --role-file=myroles.json "s3:putobjectacl" "sts:assumerole" -c

Zurücksetzen

Repokid speichert eine Kopie jeder Version der Inline-Richtlinien, die es kennt. Diese werden hinzugefügt, wenn während update_role_cache eine andere Version einer Richtlinie gefunden wird, und jedes Mal, wenn eine Repo-Aktion stattfindet. Um eine vorherige Version wiederherzustellen, führen Sie Folgendes aus:

Alle Versionen von Rollen anzeigen: repokid rollback_role <ACCOUNT_NUMBER> <ROLE_NAME> Eine bestimmte Version wiederherstellen: repokid rollback_role <ACCOUNT_NUMBER> <ROLE_NAME> --selection=<NUMBER> -c

Statistiken

Repokid zählt die Gesamtberechtigungen für jede Rolle. Statistiken werden jedes Mal hinzugefügt, wenn ein update_role_cache oder repo_role-Ereignis auftritt. Um alle Statistiken in eine CSV-Datei auszugeben, führen Sie aus: repokid repo_stats <OUTPUT_FILENAME>. Eine optionale Kontonummer kann angegeben werden, um Statistiken nur für ein bestimmtes Konto auszugeben.

Bibliothek

Neu in v0.14.2

Repokid kann als Bibliothek über das Modul repokid.lib aufgerufen werden:

from repokid.lib import display_role, repo_role, update_role_cache

account_number = "123456789012"

display_role(account_number, "superCoolRoleName")
update_role_cache(account_number)
repo_role(account_number, "superCoolRoleName", commit=True)

Dispatcher

Repokid Dispatcher ist darauf ausgelegt, Nachrichten von einer Warteschlange zu empfangen und Aktionen auszuführen. Bisher sind dies folgende Aktionen:

• Auflisten von repo-fähigen Diensten einer Rolle
• Setzen oder Entfernen eines Opt-Outs
• Auflisten und Durchführen von Rollbacks für eine Rolle

Repokid antwortet auf ein konfigurierbares SNS-Thema mit Informationen über Erfolge oder Fehlschläge. Die Dispatcher-Komponente existiert, um die Operationalisierung des Repo-Lebenszyklus in Ihrer Organisation zu unterstützen. Sie können die Warteschlange direkt für Entwickler freigeben, aber wahrscheinlicher sollte dies geschützt werden, da ein Rollback eine zerstörerische Aktion sein kann, wenn es nicht sorgfältig durchgeführt wird.

Entwicklung

Veröffentlichung

Die Versionsverwaltung erfolgt über setupmeta. So erstellen Sie eine neue Version:

python setup.py version --bump patch --push

# Überprüfen Sie die Ausgabe und stellen Sie sicher, dass sie Ihren Erwartungen entspricht
# Wenn alles in Ordnung ist, committen und pushen Sie den neuen Tag:
python setup.py version --bump patch --push --commit