Versionsinformationen finden Sie in den Versionshinweisen zu Distributed Cloud Connected.

Logs und Messwerte

Auf dieser Seite wird erläutert, wie Google Distributed Cloud Connected verschiedene Arten von Informationen zum Betrieb protokolliert und wie Sie diese Informationen aufrufen können. Für die Erhebung einiger Arten von Logs und Messwerten fallen zusätzliche Kosten an. Weitere Informationen finden Sie unter Abrechnung für Logs und Messwerte.

Logging und Monitoring konfigurieren

Bevor Sie mit dem Erfassen von Logs und Messwerten beginnen können, müssen Sie Folgendes tun:

Aktivieren Sie die Logging APIs mit den folgenden Befehlen:

gcloud services enable opsconfigmonitoring.googleapis.com --project PROJECT_ID
gcloud services enable logging.googleapis.com --project PROJECT_ID
gcloud services enable monitoring.googleapis.com --project PROJECT_ID

Ersetzen Sie PROJECT_ID durch die ID des Zielprojekts Google Cloud .

Weisen Sie die Rollen zu, die zum Schreiben von Logs und Messwerten erforderlich sind:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/opsconfigmonitoring.resourceMetadata.writer \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/metadata-agent]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/logging.logWriter \
     --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver-log-forwarder]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/monitoring.metricWriter \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/gke-metrics-agent]"

Ersetzen Sie PROJECT_ID durch die ID des Zielprojekts Google Cloud .

Logs

In diesem Abschnitt werden die von Distributed Cloud unterstützten Cloud Logging-Ressourcentypen aufgeführt. Verwenden Sie den Log-Explorer in der Google Cloud Console, um Distributed Cloud-Logs aufzurufen. Distributed Cloud-Logging ist immer aktiviert.

Die protokollierten Ressourcentypen von Distributed Cloud Connected sind die folgenden Standard-Kubernetes-Ressourcen:

k8s_container
k8s_node

Sie können auch Logs, die mit Distributed Cloud verbunden sind, mit der Cloud Logging API erfassen und abrufen. Informationen zum Konfigurieren dieses Logging-Mechanismus finden Sie in der Dokumentation zu Cloud Logging-Clientbibliotheken.

Messwerte

In diesem Abschnitt werden die von Distributed Cloud unterstützten Cloud Monitoring-Messwerte aufgeführt. Verwenden Sie den Metrics Explorer in derGoogle Cloud Console, um Distributed Cloud-Messwerte aufzurufen.

Messwerte für Distributed Cloud Connected-Cluster

Für Distributed Cloud Connected-Cluster bietet Distributed Cloud Connected die folgenden Arten von Messwerten, die von Distributed Cloud Connected-Knoten generiert werden:

Ressourcenmesswerte liefern Informationen zur Leistung von Knoten und Pods, die mit Distributed Cloud verbunden sind, z. B. zur CPU-Last und zur Arbeitsspeichernutzung.
Messwerte für Systemanwendungen liefern Informationen zu Arbeitslasten von mit Distributed Cloud verbundenen Systemen, z. B. coredns.

Eine Liste dieser Messwerte finden Sie unter Google Distributed Cloud-Messwerte.

Distributed Cloud Connected bietet keine Messwerte, die von den Kubernetes-Steuerungsebenen generiert werden, die mit Distributed Cloud Connected-Clustern verknüpft sind.

Messwerte für mit Distributed Cloud verbundene Hardware

Distributed Cloud Connected stellt Messwerte für Distributed Cloud Connected-Hardware mit den folgenden Ressourcentypen bereit:

edgecontainer.googleapis.com/Machine
edgecontainer.googleapis.com/Rack

`Machine` Ressourcenmesswerte

Distributed Cloud Connected schreibt die folgenden Cloud Monitoring API-Messwerte für die edgecontainer.googleapis.com/Machine-Ressource:

Messwert	Beschreibung
`/machine/cpu/total_cores` Art: `GAUGE` Typ: `INT`	Gesamtzahl der physischen Prozessorkerne auf dem Computer.
`/machine/cpu/usage_time` Art: `CUMULATIVE` Typ: `DOUBLE` Einheit: `Seconds`	Kumulative CPU-Nutzungszeit für alle Kerne auf dem Computer. Der Typ kann `workload` (Kundenarbeitslasten) oder `system` (alles andere) sein.
`/machine/cpu/utilization` Art: `GAUGE` Typ: `DOUBLE`	Prozentuale CPU-Auslastung auf dem Computer. Der Bereich liegt zwischen 0 und 1. Der Typ kann `workload` (Kundenarbeitslasten) oder `system` (alles andere) sein.
`/machine/memory/total_bytes` Art: `GAUGE` Typ: `INT64`	Byte-Anzahl des Gesamtspeichers auf dem Computer.
`/machine/memory/used_bytes` Art: `GAUGE` Typ: `INT64`	Anzahl der Byte des verwendeten Arbeitsspeichers auf dem Computer. `memory_type` ist entweder `evictable` (vom Kernel zurückforderbar) oder `non-evictable` (nicht zurückforderbar).
`/machine/memory/utilization` Art: `GAUGE` Typ: `DOUBLE`	Prozentuale Arbeitsspeichernutzung auf dem Computer. Der Bereich liegt zwischen 0 und 1. `memory_type` ist entweder `evictable` (vom Kernel zurückforderbar) oder `non-evictable` (nicht zurückforderbar).
`/machine/network/up` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob die Netzwerkschnittstelle aktiv ist. Enthält primäre Karten, sekundäre Karten und Ports.
`/machine/network/link_speed` Art: `GAUGE` Typ: `DOUBLE` Einheit: Byte pro Sekunde	Linkgeschwindigkeit der primären Netzwerkkarte.
`/machine/network/received_bytes_count` Art: `CUMULATIVE` Typ: `DOUBLE`	Anzahl der empfangenen Byte für die primäre Netzwerkkarte.
`/machine/network/sent_bytes_count` Art: `CUMULATIVE` Typ: `DOUBLE`	Anzahl der gesendeten Byte für die primäre Netzwerkkarte.
`/machine/network/connectivity` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob die primäre Netzwerkschnittstellenkarte eine Internetverbindung hat.
`/machine/disk/total_bytes` Art: `GAUGE` Typ: `INT64`	Byte-Anzahl des gesamten Festplattenspeicherplatzes auf dem Computer.
`/machine/disk/used_bytes` Art: `GAUGE` Typ: `INT64`	Anzahl der Byte des verwendeten Speicherplatzes auf dem Computer.
`/machine/disk/utilization` Art: `GAUGE` Typ: `DOUBLE`	Prozentsatz der Speicherplatzauslastung auf dem Computer. Der Bereich liegt zwischen 0 und 1.
`/machine/restart_count` Art: `CUMULATIVE` Typ: `INT`	Anzahl der Neustarts des Geräts.
`/machine/uptime` Art: `GAUGE` Typ: `INT` Einheit: `Seconds`	Betriebszeit des Geräts seit dem letzten Neustart.
`/machine/connected` Art: `GAUGE` Typ: `INT64`	Gibt an, ob der Computer mit Google Cloudverbunden ist.

`Rack` Ressourcenmesswerte

Distributed Cloud Connected schreibt die folgenden Cloud Monitoring API-Messwerte für die edgecontainer.googleapis.com/Rack-Ressource:

Messwert	Beschreibung
`/router/bgp_up` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob die BGP-Peering-Sitzung auf dem Router aktiv und fehlerfrei ist. `router_id` gibt den jeweiligen Router an (bis zu 2 pro Rack).
`/router/connected` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob der BGP-Router mit Google Cloudverbunden ist. `router_id` gibt den jeweiligen Router an (bis zu 2 pro Rack).

Messwerte für Sicherungsvorgänge für virtuelle Maschinen

Distributed Cloud Connected erfasst und exportiert die folgenden Messwerte im Zusammenhang mit dem VM-Sicherungs-Agent:

Messwert	Beschreibung
`gdc_backup_backups_completed` Art: `COUNTER`	Die Anzahl der erfolgreich abgeschlossenen Sicherungen virtueller Maschinen.
`gdc_backup_backups_latency` Art: `HISTOGRAM`	Die Latenz von VM-Sicherungen in Minuten.
`gdc_backup_volume_backups_created` Art: `COUNTER`	Die Anzahl der bisher erstellten Volume-Sicherungen.
`gdc_backup_volume_backups_completed` Art: `COUNTER`	Die Anzahl der bisher abgeschlossenen Volume-Sicherungen.
`gdc_backup_restores_completed` Art: `COUNTER`	Die Anzahl der bisher abgeschlossenen Wiederherstellungen virtueller Maschinen.
`gdc_backup_restores_latency` Art: `HISTOGRAM`	Die Latenz von VM-Wiederherstellungen in Minuten.
`gdc_backup_volume_restores_created` Art: `COUNTER`	Die Anzahl der bisher erstellten Volume-Wiederherstellungen.
`gdc_backup_volume_restores_completed` Art: `COUNTER`	Die Anzahl der bisher abgeschlossenen Volume-Wiederherstellungen.

Distributed Cloud Connected erfasst und exportiert die folgenden Messwerte im Zusammenhang mit der Steuerungsebene für die Sicherung virtueller Maschinen:

Messwert	Beschreibung
`gdc_backup_controlplane_live` Art: `GAUGE`	Gibt an, ob die Backup-Steuerungsebene betriebsbereit ist.
`gdc_backup_backup_repositories_attached` Art: `GAUGE`	Die Anzahl der angehängten Sicherungs-Repositories.
`gdc_backup_backups_created` Art: `COUNTER`	Die Anzahl der bisher erstellten VM-Sicherungen.
`gdc_backup_backups_deleted` Art: `COUNTER`	Die Anzahl der bisher gelöschten Sicherungen virtueller Maschinen.
`gdc_backup_restores_created` Art: `COUNTER`	Die Anzahl der bisher erstellten VM-Wiederherstellungen.
`gdc_gdc_backup_backups_pile_up` Art: `GAUGE`	Gibt an, ob ein Sicherungsplan das Limit für die Anzahl der laufenden Sicherungen erreicht hat.

Distributed Cloud Connected erfasst und exportiert die folgenden Messwerte in Bezug auf die Abrechnung der Funktion zur Sicherung virtueller Maschinen:

Messwert	Beschreibung
`metering_protected_resources_total` Quelle: VM-Sicherungsagent Art: `COUNTER`	Gesamtzahl der bisher gesicherten virtuellen Maschinen.
`metering_deleted_resources_total` Quelle: Steuerungsebene für VM-Sicherungen Art: `COUNTER`	Gesamtzahl der bisher gelöschten Sicherungen virtueller Maschinen.

Benutzerdefinierte Anwendungslogs und ‑messwerte exportieren

Distributed Cloud Connected exportiert automatisch Logs für Anwendungen, die auf Distributed Cloud Connected-Arbeitslasten ausgeführt werden. Wenn Sie Messwerte für eine Anwendung exportieren möchten, die auf mit Distributed Cloud verbundenen Arbeitslasten ausgeführt wird, müssen Sie sie wie im nächsten Abschnitt beschrieben annotieren.

Arbeitslast annotieren, um den Export von Messwerten zu aktivieren

Fügen Sie dem Dienst- oder Bereitstellungsmanifest der Anwendung die folgenden Anmerkungen hinzu, um das Erfassen benutzerdefinierter Messwerte aus einer Anwendung zu aktivieren:

prometheus.io/scrape: "true"
prometheus.io/path: "ENDPOINT_PATH". Ersetzen Sie ENDPOINT_PATH durch den vollständigen Pfad zum Messwertendpunkt der Zielanwendung.
prometheus.io/port: "PORT_NUMBER": Der Port, an dem der Metrikendpunkt der Anwendung auf Verbindungen wartet.

Beispielanwendung ausführen

In diesem Abschnitt erstellen Sie eine Anwendung, die benutzerdefinierte Logs schreibt und einen benutzerdefinierten Messwertendpunkt bereitstellt.

Speichern Sie die folgenden Dienst- und Deployment-Manifeste in einer Datei mit dem Namen my-app.yaml. Der Dienst hat die prometheus.io/scrape: "true"-Annotation:

kind: Service
apiVersion: v1
metadata:
  name: "monitoring-example"
  namespace: "default"
  annotations:
    prometheus.io/scrape: "true"
spec:
  selector:
    app: "monitoring-example"
  ports:
    - name: http
      port: 9090
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: "monitoring-example"
  namespace: "default"
  labels:
    app: "monitoring-example"
spec:
  replicas: 1
  selector:
    matchLabels:
      app: "monitoring-example"
  template:
    metadata:
      labels:
        app: "monitoring-example"
    spec:
      containers:
      - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
        name: prometheus-example-exporter
        imagePullPolicy: Always
        command:
        - /bin/sh
        - -c
        - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
        resources:
          requests:
            cpu: 100m

Erstellen Sie das Deployment und den Dienst:

kubectl --kubeconfig apply -f my-app.yaml

Anwendungslogs aufrufen.

Console

Rufen Sie in der Console von Google Cloud die Seite Log-Explorer auf.
Zum Log-Explorer
Klicken Sie auf Ressource.
Wählen Sie in der Liste Alle Ressourcentypen die Option Kubernetes Container aus.
Wählen Sie unter Clustername den Namen Ihres Nutzerclusters aus.
Wählen Sie bei Namespace-Name die Option default aus.
Klicken Sie auf Hinzufügen und dann auf Abfrage ausführen.

Im Abschnitt Abfrageergebnisse sehen Sie die Logeinträge des Deployments monitoring-example. Beispiel:

{
  "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n",
  "insertId": "1oa4vhg3qfxidt",
  "resource": {
    "type": "k8s_container",
    "labels": {
      "pod_name": "monitoring-example-7685d96496-xqfsf",
      "cluster_name": ...,
      "namespace_name": "default",
      "project_id": ...,
      "location": "us-west1",
      "container_name": "prometheus-example-exporter"
    }
  },
  "timestamp": "2020-11-14T01:24:24.358600252Z",
  "labels": {
    "k8s-pod/pod-template-hash": "7685d96496",
    "k8s-pod/app": "monitoring-example"
  },
  "logName": "projects/.../logs/stdout",
  "receiveTimestamp": "2020-11-14T01:24:39.562864735Z"
}

gcloud

Führen Sie den Befehl gcloud logging read aus:

gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
    resource.type="k8s_container" AND resource.labels.namespace_name="default"'

Ersetzen Sie PROJECT_ID durch die ID Ihres Projekts.

In der Ausgabe sehen Sie die Logeinträge des Deployments monitoring-example. Beispiel:

insertId: 1oa4vhg3qfxidt
labels:
  k8s-pod/app: monitoring-example
  k8s- pod/pod-template-hash: 7685d96496
logName: projects/.../logs/stdout
receiveTimestamp: '2020-11-14T01:24:39.562864735Z'
resource:
  labels:
    cluster_name: ...
    container_name: prometheus-example-exporter
    location: us-west1
    namespace_name: default
    pod_name: monitoring-example-7685d96496-xqfsf
    project_id: ...
  type: k8s_container
textPayload: |
  2020/11/14 01:24:24 Starting to listen on :9090
timestamp: '2020-11-14T01:24:24.358600252Z'

Anwendungsmesswerte ansehen

Ihre Beispielanwendung stellt einen benutzerdefinierten Messwert namens example_monitoring_up bereit. Die Werte dieses Messwerts finden Sie in der Google Cloud Console.

Wechseln Sie in der Google Cloud Console zur Seite Metrics Explorer.
Zum Metrics Explorer
Wählen Sie Kubernetes Pod als Ressourcentyp aus.
Wählen Sie external/prometheus/example_monitoring_up als Messwert aus.
Im Diagramm sehen Sie, dass example_monitoring_up einen wiederkehrenden Wert von 1 hat.

Messwerte mit Prometheus erfassen

Distributed Cloud Connected unterstützt die Prometheus-Messwertlösung zum Erfassen von Messwerten für Ihre Distributed Cloud Connected-Arbeitslasten.

Dazu wird in Distributed Cloud Connected beim Erstellen eines Distributed Cloud Connected-Clusters ein nicht verwalteter Namespace mit dem Namen prom-monitoring erstellt. Wir empfehlen, diesen Namespace zum Bereitstellen von Prometheus zu verwenden. Sie können die erforderlichen Ressourcen auch aus dem Namespace prom-monitoring in einen Namespace Ihrer Wahl kopieren und Prometheus dort bereitstellen.

Extrahierung von Prometheus-Messwerten konfigurieren

Wenn Sie Messwerte für Distributed Cloud Connected mit Prometheus erfassen möchten, müssen Sie das Extrahieren von Prometheus-Messwerten konfigurieren. Dazu müssen Sie die ConfigMap prometheus-scrape-config in Ihrem Prometheus-Pod einbinden und die Scrape-Konfiguration aus der ConfigMap in Ihre Prometheus-Konfiguration einfügen. Beispiel:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus-local-rolebinding
  namespace: prom-monitoring
subjects:
- kind: ServiceAccount
  name: prometheus-scrape
  namespace: prom-monitoring
roleRef:
  kind: ClusterRole
  name: gke-metrics-agent
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: prom-monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 5s
      evaluation_interval: 5s
    rule_files:
    scrape_config_files:
    - /etc/prometheus/scrape/*.yml
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: prom-monitoring
spec:
  selector:
    app: prom-monitoring
  ports:
  - port: 9090
    targetPort: 9090
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-deployment
  namespace: prom-monitoring
  labels:
    app: prom-monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prom-monitoring
  template:
    metadata:
      labels:
        app: prom-monitoring
    spec:
      serviceAccountName: prometheus-scrape
      containers:
        - name: prometheus
          image: prom/prometheus:main
          args:
            - "--config.file=/etc/prometheus/prometheus.yml"
            - "--storage.tsdb.path=/prometheus/"
          ports:
            - containerPort: 9090
          volumeMounts:
            - name: prometheus-config-volume
              mountPath: /etc/prometheus/
            - name: prometheus-scrape-config-volume
              mountPath: /etc/prometheus/scrape/
            - name: prometheus-storage-volume
              mountPath: /prometheus/
            - name: prometheus-scrape-token
              mountPath: /var/run/secrets/kubernetes.io/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-scrape-cert
              mountPath: /certs/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-etcd-scrape
              mountPath: /stackdriver-prometheus-etcd-scrape
      volumes:
        - name: prometheus-storage-volume
          emptyDir: {}
        - name: prometheus-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-config
        - name: prometheus-scrape-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-scrape-config
        - name: prometheus-scrape-token
          secret:
            defaultMode: 420
            secretName: prometheus-scrape
        - name: stackdriver-prometheus-scrape-cert
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-scrape-cert
        - name: stackdriver-prometheus-etcd-scrape
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-etcd-scrape

Wenn Sie Arbeitslastmesswerte mit Prometheus erfassen möchten, müssen Sie den Diensten und Pods, die die Zielarbeitslasten ausführen, Anmerkungen hinzufügen:

Wenn Sie Messwerte sowohl an Cloud Monitoring als auch an Prometheus senden möchten, verwenden Sie die unter Benutzerdefinierte Logs und Messwerte exportieren beschriebenen Annotationen.
Wenn Sie Messwerte nur an Prometheus senden möchten, verwenden Sie die folgenden Annotationen:

prometheus.io/unmanaged_scrape: "true"
prometheus.io/unmanaged_path: "ENDPOINT_PATH"
prometheus.io/unmanaged_port: "PORT_NUMBER"

Logs mit Kafka erfassen

Distributed Cloud Connected unterstützt die Apache Kafka-Lösung zum Erfassen von Logs für Arbeitslasten, die in Ihrer Distributed Cloud Connected-Bereitstellung ausgeführt werden.

Bevor Sie die Schritte in diesem Abschnitt ausführen, muss eine funktionierende Kafka-Bereitstellung vorhanden sein. Ihre Kafka-Broker müssen ihre Listener im PLAINTEXT-Modus bewerben. SSL-/SASL-bezogene Variablen werden nicht unterstützt.

Wenn Sie einen Cluster für die Kafka-Protokollierung konfigurieren möchten, müssen Sie eine JSON-Datei erstellen, in der die Add-ons konfiguriert werden, die Sie im Cluster ausführen möchten. Geben Sie diese Datei an, wenn Sie einen Cluster mit dem Flag --system-addons-config erstellen. Wenn Sie die Kafka-Konfiguration ändern müssen, müssen Sie den Cluster löschen und mit den neuen Kafka-Einstellungen neu erstellen.

Fügen Sie der Konfigurationsdatei für System-Add-ons den folgenden Abschnitt hinzu:

{
        "systemAddonsConfig": {
          "unmanagedKafkaConfig": {
            "brokers": "BROKERS",
            "topics": "TOPICS"
     "topic_key": "TOPIC_KEY, 
          }
      }
}

Ersetzen Sie Folgendes:

BROKERS: Eine durch Kommas getrennte Liste von Broker-IP-Adressen und Portpaaren im ip_address:port-Format.
TOPICS: Eine durch Kommas getrennte Liste von Kafka-Themen.
TOPIC_KEY: Ein Kafka-Themaschlüssel. Damit kann Kafka ein Thema auswählen, wenn mehrere Themen vorhanden sind.

Wenn Kafka nach dem Erstellen des verbundenen Clusters für Distributed Cloud keine Logs erfasst, prüfen Sie Folgendes:

Serverseitig:Prüfen Sie die Fehlerprotokolle in Ihrer Kafka-Bereitstellung auf Hinweise auf ein Problem.
Clientseite:Wenden Sie sich an den Google-Support, um System-Pod-Logs abzurufen und zu untersuchen.

Rohprotokolle für Arbeitslasten zur externen Verarbeitung erfassen

Sie können Distributed Cloud Connected so konfigurieren, dass Rohlogs (unverarbeitet und ohne Tags) von Arbeitslast-Pods nach /var/logs/export exportiert werden. So können Sie Ihren eigenen Log-Collector für die Logverarbeitung verwenden.

Wenn Sie den Export von Roharbeitslastlogs konfigurieren möchten, erstellen Sie eine benutzerdefinierte LogExport-Ressource mit dem folgenden Inhalt und wenden Sie sie dann auf Ihren Cluster an:

apiVersion: gdc.addons.gke.io/v1
kind: LogExport
metadata:
  name: my-log-export
spec:
  namespaces:
  - namespace1
  - namespace2
  - namespace3

Geben Sie im Feld namespaces die Arbeitslast-Namespaces an, für die Sie Roh-Pod-Logs exportieren möchten. Im Feld sind keine System-Namespaces zulässig, z. B. die in den Einschränkungen für Management-Namespaces aufgeführten.

Nächste Schritte

Audit-Logging

Logs und Messwerte Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.