

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Cache-Builds zur Verbesserung der Leistung
<a name="build-caching"></a>

Sie können Zeit sparen, wenn beim Erstellen Ihres Projekts ein Cache verwendet wird. In einem Cache können wiederverwendbare Teile Ihrer Build-Umgebung gespeichert werden, die dann für mehrere Builds verwendet werden können. Ihr Build-Projekt kann eine von zwei Arten von Caching verwenden: Amazon S3 oder lokal. Wenn Sie einen lokalen Cache verwenden, müssen Sie mindestens einen von drei Cache-Modi auswählen: Quellcache, Docker-Ebenen-Cache und benutzerdefinierter Cache. 

**Anmerkung**  
Der Docker-Ebenen-Cache-Modus ist nur für die Linux-Umgebung verfügbar. Wenn Sie diesen Modus wählen, müssen Sie Ihren Build im privilegierten Modus ausführen. CodeBuild Der privilegierte Modus für Projekte gewährt seinem Container Zugriff auf alle Geräte. Weitere Informationen finden Sie unter [Laufzeitberechtigungen und Linux-Funktionen](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) auf der Docker-Docs-Website.

**Topics**
+ [Amazon S3 S3-Caching](caching-s3.md)
+ [Lokales Caching](caching-local.md)
+ [Geben Sie einen lokalen Cache an](specify-caching-local.md)

# Amazon S3 S3-Caching
<a name="caching-s3"></a>

Amazon S3 S3-Caching speichert den Cache in einem Amazon S3 S3-Bucket, der auf mehreren Build-Hosts verfügbar ist. Dies ist eine gute Option für kleine bis mittelgroße Build-Artefakte, deren Erstellung teurer ist als das Herunterladen.

Um Amazon S3 in einem Build zu verwenden, können Sie die Pfade für die Dateien angeben, in denen Sie zwischenspeichern möchten`buildspec.yml`. CodeBuild speichert und aktualisiert den Cache automatisch an dem für das Projekt konfigurierten Amazon S3 S3-Speicherort. Wenn Sie die Dateipfade nicht angeben, CodeBuild werden gängige Sprachabhängigkeiten nach besten Kräften zwischengespeichert, um Ihnen zu helfen, die Builds zu beschleunigen. Sie können die Cache-Details in den Build-Logs einsehen.

Wenn Sie mehrere Versionen des Caches haben möchten, können Sie außerdem einen Cache-Schlüssel in der definieren`buildspec.yml`. CodeBuild speichert den Cache im Kontext dieses Cache-Schlüssels und erstellt eine eindeutige Cache-Kopie, die nach der Erstellung nicht aktualisiert wird. Die Cache-Schlüssel können auch projektübergreifend gemeinsam genutzt werden. Funktionen wie dynamische Schlüssel, Cache-Versionierung und gemeinsame Nutzung des Caches zwischen Builds sind nur verfügbar, wenn ein Schlüssel angegeben wird.

Weitere Informationen zur Cachesyntax in der Buildspec-Datei finden Sie [Cache](build-spec-ref.md#build-spec.cache) in der Buildspec-Referenz.

**Topics**
+ [Generieren Sie dynamische Schlüssel](#caching-s3-dynamic)
+ [codebuild-hash-files](#caching-s3-dynamic.codebuild-hash-files)
+ [Cache-Version](#caching-s3-version)
+ [Gemeinsame Nutzung von Caches zwischen Projekten](#caching-s3-sharing)
+ [Buildspec-Beispiele](#caching-s3-examples)

## Generieren Sie dynamische Schlüssel
<a name="caching-s3-dynamic"></a>

Ein Cache-Schlüssel kann Shell-Befehle und Umgebungsvariablen enthalten, um ihn einzigartig zu machen und automatische Cache-Aktualisierungen zu ermöglichen, wenn sich der Schlüssel ändert. Sie können beispielsweise einen Schlüssel mithilfe des Hash der `package-lock.json` Datei definieren. Wenn sich die Abhängigkeiten in dieser Datei ändern, ändert sich der Hash — und damit der Cache-Schlüssel —, was die automatische Erstellung eines neuen Caches auslöst.

```
cache:
    key: npm-key-$(codebuild-hash-files package-lock.json)
```

CodeBuild wertet den Ausdruck aus, um den endgültigen Schlüssel `$(codebuild-hash-files package-lock.json)` zu erhalten:

```
npm-key-abc123
```

Sie können einen Cache-Schlüssel auch mithilfe von Umgebungsvariablen definieren, wie `CODEBUILD_RESOLVED_SOURCE_VERSION` z. Dadurch wird sichergestellt, dass bei jeder Änderung Ihrer Quelle ein neuer Schlüssel generiert wird, was dazu führt, dass automatisch ein neuer Cache gespeichert wird:

```
cache:
   key: npm-key-$CODEBUILD_RESOLVED_SOURCE_VERSION
```

CodeBuild wertet den Ausdruck aus und erhält den endgültigen Schlüssel:

```
npm-key-046e8b67481d53bdc86c3f6affdd5d1afae6d369
```

## codebuild-hash-files
<a name="caching-s3-dynamic.codebuild-hash-files"></a>

`codebuild-hash-files`ist ein CLI-Tool, das mithilfe von Glob-Mustern einen SHA-256-Hash für eine Reihe von Dateien im CodeBuild Quellverzeichnis berechnet:

```
codebuild-hash-files <glob-pattern-1> <glob-pattern-2> ...
```

Hier sind einige Beispiele für die Verwendung von: `codebuild-hash-files`

```
codebuild-hash-files package-lock.json
codebuild-hash-files '**/*.md'
```

## Cache-Version
<a name="caching-s3-version"></a>

Die Cache-Version ist ein Hash, der aus den Pfaden der zwischengespeicherten Verzeichnisse generiert wird. Wenn zwei Caches unterschiedliche Versionen haben, werden sie beim Abgleichen als unterschiedliche Caches behandelt. Beispielsweise werden die folgenden beiden Caches als unterschiedlich betrachtet, da sie auf unterschiedliche Pfade verweisen:

```
version: 0.2

phases:
  build:
    commands:
      - pip install pandas==2.2.3 --target pip-dependencies
cache:
  key: pip-dependencies 
  paths:
    - "pip-dependencies/**/*"
```

```
version: 0.2

phases:
  build:
    commands:
      - pip install pandas==2.2.3 --target tmp/pip-dependencies
cache:
  key: pip-dependencies 
  paths:
    - "tmp/pip-dependencies/**/*"
```

## Gemeinsame Nutzung von Caches zwischen Projekten
<a name="caching-s3-sharing"></a>

Sie können das `cacheNamespace` API-Feld unter dem `cache` Abschnitt verwenden, um einen Cache für mehrere Projekte gemeinsam zu nutzen. Dieses Feld definiert den Umfang des Caches. Um einen Cache gemeinsam zu nutzen, müssen Sie wie folgt vorgehen:
+ Verwenden Sie dasselbe`cacheNamespace`.
+ Geben Sie denselben Cache an`key`.
+ Definieren Sie identische Cache-Pfade.
+ Verwenden Sie dieselben Amazon S3 S3-Buckets und `pathPrefix` falls festgelegt.

Dies gewährleistet Konsistenz und ermöglicht die gemeinsame Nutzung des Caches zwischen Projekten.

### Geben Sie einen Cache-Namespace (Konsole) an
<a name="caching-s3-sharing.console"></a>

1. Öffnen Sie die AWS CodeBuild Konsole unter [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Wählen Sie **Create project** (Projekt erstellen) aus. Weitere Informationen finden Sie unter [Erstellen Sie ein Build-Projekt (Konsole)](create-project.md#create-project-console) und [Ausführen eines Build (Konsole)](run-build-console.md).

1. **Wählen Sie unter **Artefakte** die Option Zusätzliche Konfiguration aus.**

1. Wählen Sie als **Cachetyp** **Amazon S3** aus.

1. Geben Sie für **Cache-Namespace — optional** einen Namespace-Wert ein.  
![\[Cache-Namespace-Parameter in der Konsole. CodeBuild\]](http://docs.aws.amazon.com/de_de/codebuild/latest/userguide/images/s3-cache-namespace.png)

1. Fahren Sie mit den Standardwerten fort und wählen Sie dann **Build-Projekt erstellen**.

### Geben Sie einen Cache-Namespace an ()AWS CLI
<a name="caching-s3-sharing.cli"></a>

Sie können den `--cache` Parameter in verwenden, AWS CLI um einen Cache-Namespace anzugeben.

```
--cache '{"type": "S3", "location": "your-s3-bucket", "cacheNamespace": "test-cache-namespace"}'
```

## Buildspec-Beispiele
<a name="caching-s3-examples"></a>

Hier sind einige Buildspec-Beispiele für gängige Sprachen:

**Topics**
+ [Abhängigkeiten von Node.js zwischenspeichern](#caching-s3-examples.nodejs)
+ [Python-Abhängigkeiten zwischenspeichern](#caching-s3-examples.python)
+ [Ruby-Abhängigkeiten zwischenspeichern](#caching-s3-examples.ruby)
+ [Cache Go-Abhängigkeiten](#caching-s3-examples.go)

### Abhängigkeiten von Node.js zwischenspeichern
<a name="caching-s3-examples.nodejs"></a>

Wenn Ihr Projekt eine `package-lock.json` Datei enthält und `npm` zur Verwaltung der Abhängigkeiten von Node.js verwendet wird, zeigt das folgende Beispiel, wie Sie das Caching einrichten. `npm`Installiert standardmäßig Abhängigkeiten in das `node_modules` Verzeichnis.

```
version: 0.2

phases:
  build:
    commands:
      - npm install
cache:
  key: npm-$(codebuild-hash-files package-lock.json)
  paths:
    - "node_modules/**/*"
```

### Python-Abhängigkeiten zwischenspeichern
<a name="caching-s3-examples.python"></a>

Wenn Ihr Projekt eine `requirements.txt` Datei enthält und Pip zur Verwaltung von Python-Abhängigkeiten verwendet, zeigt das folgende Beispiel, wie Sie das Caching konfigurieren. Standardmäßig installiert Pip Pakete in das Verzeichnis des Systems. `site-packages`

```
version: 0.2

phases:
  build:
    commands:
      - pip install -r requirements.txt
cache:
  key: python-$(codebuild-hash-files requirements.txt)
  paths:
    - "/root/.pyenv/versions/${python_version}/lib/python${python_major_version}/site-packages/**/*"
```

Darüber hinaus können Sie Abhängigkeiten in einem bestimmten Verzeichnis installieren und das Caching für dieses Verzeichnis konfigurieren.

```
version: 0.2

phases:
  build:
    commands:
      - pip install -r requirements.txt --target python-dependencies
cache:
  key: python-$(codebuild-hash-files requirements.txt)
  paths:
    - "python-dependencies/**/*"
```

### Ruby-Abhängigkeiten zwischenspeichern
<a name="caching-s3-examples.ruby"></a>

Wenn Ihr Projekt eine `Gemfile.lock` Datei enthält und diese `Bundler` zur Verwaltung von Gem-Abhängigkeiten verwendet, zeigt das folgende Beispiel, wie Sie das Caching effektiv konfigurieren können.

```
version: 0.2

phases:
  build:
    commands:
      - bundle install --path vendor/bundle
cache:
  key: ruby-$(codebuild-hash-files Gemfile.lock)
  paths:
    - "vendor/bundle/**/*"
```

### Cache Go-Abhängigkeiten
<a name="caching-s3-examples.go"></a>

Wenn Ihr Projekt eine `go.sum` Datei enthält und Go-Module zur Verwaltung von Abhängigkeiten verwendet, zeigt das folgende Beispiel, wie Sie das Caching konfigurieren. Standardmäßig werden Go-Module heruntergeladen und im `${GOPATH}/pkg/mod` Verzeichnis gespeichert.

```
version: 0.2

phases:
  build:
    commands:
      - go mod download
cache:
  key: go-$(codebuild-hash-files go.sum)
  paths:
    - "/go/pkg/mod/**/*"
```

# Lokales Caching
<a name="caching-local"></a>

Beim lokalen Caching wird der Cache lokal auf einem Build-Host gespeichert und ist nur für diesen Build-Host verfügbar. Dies ist eine gute Option für mittlere bis große Build-Artefakte, da der Cache sofort auf dem Build-Host verfügbar ist. Dies ist nicht die beste Option, wenn Ihre Builds selten sind. Die Build-Leistung ist somit nicht durch die Netzwerk-Übertragungsdauer beeinträchtigt.

Wenn Sie sich für lokales Caching entscheiden, müssen Sie mindestens einen der folgenden Cache-Modi auswählen: 
+ Beim Quellcache-Modus werden Git-Metadaten für primäre und sekundäre Quellen zwischengespeichert. Nachdem der Cache erstellt wurde, wird bei nachfolgenden Builds nur die Änderung zwischen den Commits abgerufen. Dieser Modus ist gut geeignet für Projekte mit einem sauberen Arbeitsverzeichnis und einem großen Git-Repository als Quelle. Wenn du diese Option wählst und dein Projekt kein Git-Repository (AWS CodeCommit, GitHub, GitHub Enterprise Server oder Bitbucket) verwendet, wird die Option ignoriert. 
+ Beim Docker-Ebenen-Cache-Modus werden vorhandene Docker-Ebenen zwischengespeichert. Dieser Modus eignet sich für Projekte, bei denen große Docker-Images erstellt oder abgerufen werden. Mit diesem Modus können Leistungsprobleme vermieden werden, die beim Abruf großer Docker-Images aus dem Netzwerk entstehen. 
**Anmerkung**  
Ein Docker-Ebenen-Cache kann nur in einer Linux-Umgebung verwendet werden. 
Das `privileged`-Flag muss so festgelegt sein, dass Ihr Projekt über die erforderlichen Docker-Berechtigungen verfügt.   
Standardmäßig ist der Docker-Daemon für Nicht-VPC-Builds aktiviert. Wenn Sie Docker-Container für VPC-Builds verwenden möchten, lesen Sie auf der Docker Docs-Website unter [Runtime Privilege and Linux Capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) nach und aktivieren Sie den privilegierten Modus. Außerdem unterstützt Windows den privilegierten Modus nicht.
Vor der Verwendung eines Docker-Ebenen-Cache sollten Sie die Auswirkungen auf die Sicherheit berücksichtigen. 
+ Beim benutzerdefinierten Cache-Modus werden Verzeichnisse zwischengespeichert, die Sie in der buildspec-Datei angeben. Dieser Modus ist gut geeignet, wenn Ihr Build-Szenario nicht für einen der beiden anderen lokalen Cache-Modi in Frage kommt. Bei Verwendung eines benutzerdefinierte Cache gilt Folgendes: 
  + Für das Caching können nur Verzeichnisse angegeben werden. Sie können keine einzelnen Dateien angeben. 
  + Es werden Symlinks verwendet, um auf zwischengespeicherte Verzeichnisse zu verweisen. 
  + Zwischengespeicherte Verzeichnisse werden mit Ihrem Build verknüpft, bevor die Projektquellen heruntergeladen werden. Im Cache gespeicherte Elemente überschreiben Quellelemente, wenn sie denselben Namen haben. Verzeichnisse werden unter Verwendung von Cache-Pfaden in der buildspec-Datei angegeben. Weitere Informationen finden Sie unter [Syntax der Build-Spezifikation](build-spec-ref.md#build-spec-ref-syntax). 
  + Vermeiden Sie Verzeichnisnamen, die in der Quelle und im Cache identisch sind. Lokal zwischengespeicherte Verzeichnisse können die Inhalte von Verzeichnissen in einem Quell-Repository überschreiben oder löschen, das denselben Namen hat.

**Anmerkung**  
Lokales Caching wird für den `LINUX_GPU_CONTAINER` Umgebungstyp und den `BUILD_GENERAL1_2XLARGE` Compute-Typ nicht unterstützt. Weitere Informationen finden Sie unter [Berechnungsmodi und Typen der Build-Umgebung](build-env-ref-compute-types.md).

**Anmerkung**  
Lokales Caching wird nicht unterstützt, wenn Sie die Konfiguration CodeBuild für die Arbeit mit einer VPC vornehmen. Weitere Informationen zur Verwendung von VPCs mit finden Sie CodeBuild unter. [Verwendung AWS CodeBuild mit Amazon Virtual Private Cloud](vpc-support.md)

# Geben Sie einen lokalen Cache an
<a name="specify-caching-local"></a>

Sie können die Konsole AWS CLI, das SDK oder verwenden, CloudFormation um einen lokalen Cache anzugeben. Weitere Hinweise zum lokalen Caching finden Sie unter[Lokales Caching](caching-local.md).

**Topics**
+ [Angabe von lokalem Caching (CLI)](#caching-local-cli)
+ [Angabe von lokalem Caching (Konsole)](#caching-local-console)
+ [Angabe von lokalem Caching (CloudFormation)](#caching-local-cfn)

## Angabe von lokalem Caching (CLI)
<a name="caching-local-cli"></a>

Sie können den `--cache` Parameter in verwenden AWS CLI , um jeden der drei lokalen Cachetypen anzugeben. 
+ So geben Sie einen Quellcache an: 

  ```
  --cache type=LOCAL,mode=[LOCAL_SOURCE_CACHE]
  ```
+ So geben Sie eine Docker-Ebenen-Cache an: 

  ```
  --cache type=LOCAL,mode=[LOCAL_DOCKER_LAYER_CACHE]
  ```
+ So geben Sie einen benutzerdefinierten Cache an: 

  ```
  --cache type=LOCAL,mode=[LOCAL_CUSTOM_CACHE]
  ```

Weitere Informationen finden Sie unter [Erstellen eines Build-Projekts (AWS CLI)](create-project.md#create-project-cli).

## Angabe von lokalem Caching (Konsole)
<a name="caching-local-console"></a>

Geben Sie den Cache im Abschnitt **Artifacts (Artefakte)** der Konsole an. Wählen Sie als **Cachetyp** **Amazon S3** oder **Local aus**. Wenn Sie **Local (Lokal)** auswählen, wählen Sie mindestens eine der drei lokalen Cache-Optionen aus.

![\[Geben Sie einen lokalen Cache an, indem Sie eine oder mehrere der drei lokalen Cache-Optionen auswählen.\]](http://docs.aws.amazon.com/de_de/codebuild/latest/userguide/images/local-cache.png)


Weitere Informationen finden Sie unter [Erstellen Sie ein Build-Projekt (Konsole)](create-project.md#create-project-console).

## Angabe von lokalem Caching (CloudFormation)
<a name="caching-local-cfn"></a>

Wenn Sie CloudFormation einen lokalen Cache angeben, geben Sie in der `Cache` Eigenschaft for `Type` an`LOCAL`. Der folgende CloudFormation Beispielcode im YAML-Format spezifiziert alle drei lokalen Cachetypen. Sie können eine beliebige Kombination der Typen angeben. Wenn Sie einen Docker-Ebenen-Cache verwenden, müssen Sie unter `Environment` (Umgebung) für `PrivilegedMode` die Option `true` und für `Type` (Typ) die Option `LINUX_CONTAINER` festlegen. 

```
CodeBuildProject:
    Type: AWS::CodeBuild::Project
    Properties:
      Name: MyProject
      ServiceRole: <service-role>
      Artifacts:
        Type: S3
        Location: <bucket-name>
        Name: myArtifact
        EncryptionDisabled: true
        OverrideArtifactName: true
      Environment:
        Type: LINUX_CONTAINER
        ComputeType: BUILD_GENERAL1_SMALL
        Image: aws/codebuild/standard:5.0
        Certificate: <bucket/cert.zip>
        # PrivilegedMode must be true if you specify LOCAL_DOCKER_LAYER_CACHE
        PrivilegedMode: true
      Source:
        Type: GITHUB
        Location: <github-location>
        InsecureSsl: true
        GitCloneDepth: 1
        ReportBuildStatus: false
      TimeoutInMinutes: 10
      Cache:
        Type: LOCAL
        Modes: # You can specify one or more cache mode, 
          - LOCAL_CUSTOM_CACHE
          - LOCAL_DOCKER_LAYER_CACHE
          - LOCAL_SOURCE_CACHE
```

**Anmerkung**  
Standardmäßig ist der Docker-Daemon für Nicht-VPC-Builds aktiviert. Wenn Sie Docker-Container für VPC-Builds verwenden möchten, lesen Sie auf der Docker Docs-Website unter [Runtime Privilege and Linux Capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) nach und aktivieren Sie den privilegierten Modus. Außerdem unterstützt Windows den privilegierten Modus nicht.

Weitere Informationen finden Sie unter [Erstellen eines Build-Projekts (CloudFormation)](create-project.md#create-project-cloud-formation).