Installation der Custom Edition in einer Air-Gapped-Umgebung

Eine Air-Gapped-Umgebung ist ein Netzwerk, das aus Sicherheitsgründen physisch von externen Netzwerken isoliert ist. Sie können die Custom Edition in einer Air-Gapped-Umgebung installieren.

Voraussetzungen

Stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind.

Instana Der Verkaufsschlüssel und der Downloadschlüssel werden abgerufen.
Instana und Datenspeicher-Container-Images werden heruntergeladen.

Sicherheit

Zugelassene sichere Medien (USB-Sticks oder Ähnliches) für die Übertragung von Artefakten
Einhaltung der Air-Gap-Sicherheitsrichtlinien Ihres Unternehmens

Tools

kubectl ist für Ihren Cluster installiert und konfiguriert.
Helm ist installiert (oder bereit für die Offline-Installation).
Docker oder Podman für die Bearbeitung von Bildern.
(Optional): Skopeo zum Kopieren von Bildern zwischen Registrierungen.

Berechtigungen und Anmeldedaten

Zugang zu einem Online-Rechner zum Herunterladen von Artefakten
Cluster-Administratorberechtigung zum Bereitstellen der Custom Edition.
Anmeldedaten für:
- Instana Artefakt-Repository ($DOWNLOAD_KEY)
- Interne Container-Registrierung (Benutzername und Passwort)

Vorgehensweise

Um die selbst gehostete Custom Edition ( Kubernetes oder Red Hat OpenShift Container Platform ) in einer Air-Gapped-Umgebung zu installieren, führen Sie die folgenden Schritte aus:

Hinweis:

Sie müssen vor Beginn der Installation Geheimnisse anlegen. Andernfalls werden die Geheimnisse automatisch generiert. Sie können bereits vorhandene Geheimnisse für alle Diagramme der Datenspeicher- Helm s konfigurieren.

Hinweis:

Der Jump-Host muss mit dem Internet verbunden sein und Zugriff auf den Air-Gapped-Cluster oder die Umgebung haben, in der das „ Instana “-Backend installiert wird.

Hinweis:

Die in den Beispielen enthaltenen Bilder sind für Linux x86_64 bestimmt.

Bilder zu „ Linux on IBM Z and LinuxONE “ finden Sie unter „Installation von Datenspeichern“ auf Linux on IBM Z and LinuxONE.
Bilder zur „ Linux on Power “ finden Sie unter „Installation von Datenspeichern“ auf Linux on Power ( ppc64le ).

Umgebung einrichten.
1. Kubernetes -Cluster, Speicher und Netzwerk vorbereiten.
2. Voraussetzungen überprüfen: Kubernetes und Helm Versionen
Installieren Sie das Plug-in „ Instana “ ( kubectl ), siehe „Installieren des Plug-ins „ Instana “ ( kubectl ).

Installieren Sie „ Helm “:

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

Überprüfen Sie die Versionen von „ Instana “ und „Operator“:
```
kubectl instana -v
 
```

Rufen Sie die Liste der Bilder auf dem Backend von Instana ab:

kubectl instana versions list-images -d $DOWNLOAD_KEY

Sie sehen eine Ausgabe, die der folgenden Ausgabe ähnelt:

artifact-public.instana.io/backend/acceptor:3.xxx.xxx-0
...
...
artifact-public.instana.io/backend/gateway:1.26.3_v0.46.0
artifact-public.instana.io/backend/config-templates:3.xxx.xxx-0
artifact-public.instana.io/infrastructure/instana-enterprise-operator:1.3.0
artifact-public.instana.io/infrastructure/instana-enterprise-operator-webhook:1.3.0

Artefakte hochladen:
1. Export-Download-Schlüssel:
```
export DOWNLOAD_KEY="<download_key>"
 
```
2. Melden Sie sich bei der Registrierungsstelle „ Instana “ an:
  
  Hinweis:
  Führen Sie einen der folgenden Befehle aus, je nachdem, ob Sie Skopeo oder Docker verwenden.
  - Skopeo:
```
skopeo login -u _ -p $DOWNLOAD_KEY artifact-public.instana.io
 
```
  - Docker:
```
docker login -u _ -p $DOWNLOAD_KEY artifact-public.instana.io
 
```
3. Melden Sie sich bei der internen Bildregistrierung an
  - Skopeo:
```
skopeo login -u <your_internal_artifactory_username> -p <your_internal_artifactory_password> <internal-image-registry>
 
```
  - Docker:
```
docker login -u <your_internal_artifactory_username> -p <your_internal_artifactory_password> <internal-image-registry>
 
```
    Ändern Sie nicht den tatsächlichen Namen der Bilder. Ändern Sie nur die Artifactory- URL - und Pfadangaben. Wenn Sie beispielsweise ausführen kubectl instana versions list-images und der zurückgegebene Bildname lautet artifact-public.instana.io/backend/acceptor:3.xxx.xxx–x, müssen Sie das Bild im folgenden Format in Ihr internes Artifactory übertragen: <internal-image-registry>/<internal-image-repository-path>/acceptor:<tag_of_image>.

Benutzerdefinierte Edition installieren:

Erstellen Sie Namespaces für „ Instana “:

for ns in cert-manager instana-kafka instana-clickhouse instana-postgres instana-cassandra instana-elastic instana-core instana-units instana-operator; do kubectl create namespace $ns; done

Erstellen Sie Image-Pull-Geheimnisse in den Namespaces „ Instana “.

 for ns in cert-manager instana-kafka instana-clickhouse instana-postgres instana-cassandra instana-elastic instana-core instana-units instana-operator; do kubectl create secret docker-registry instana-registry --docker-server=<internal-image-registry> --docker-username=<your_internal_artifactory_username> --docker-password=<your_internal_artifactory_password> -n $ns; done

Bei der internen Bildregistrierung von „ OpenShift Container Platform “ kann dieser Schritt übersprungen werden.

Artefakte herunterladen und in eine interne Bildregistrierung hochladen

Hinweis:

Kopieren Sie die Images von Ihrem Bastion-Host in Ihr eigenes internes Image-Repository. Führen Sie einen der folgenden Schritte aus, je nachdem, ob Sie Skopeo oder Docker verwenden. Ändern Sie nicht den tatsächlichen Namen der Bilder. Ändern Sie nur die Artifactory- URL - und Pfadangaben. Wenn Sie beispielsweise den Befehl ausführen und kubectl instana versions list-images als Bildnamen zurückerhalten artifact-public.instana.io/backend/acceptor:3.xxx.xxx–x, müssen Sie das Bild im folgenden Format in Ihr internes Artifactory hochladen: <interne-Bild-Registry>/<interner-Bild-Repository-Pfad>/acceptor:<Tag_des_Bildes>.

Skopeo:

Kopieren Sie die Strimzi-Bilder:

skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/operator/strimzi:1.0.1_v0.33.0 docker://<internal-image-registry>/<internal-image-repository-path>/strimzi:1.0.1_v0.33.0
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/datastore/kafka:1.0.1-kafka-4.1.2_v0.37.0 docker://<internal-image-registry>/<internal-image-repository-path>/kafka:1.0.1-kafka-4.1.2_v0.37.0

Kopieren Sie die Bilder „ Elasticsearch “:

skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/operator/elasticsearch:3.4.1_v0.34.0 docker://<internal-image-registry>/<internal-image-repository-path>/elasticsearch-operator:3.4.1_v0.34.0
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/datastore/elasticsearch:8.19.18_v0.37.0 docker://<internal-image-registry>/<internal-image-repository-path>/elasticsearch:8.19.18_v0.37.0

Kopieren Sie die Bilder „ CNPG “ und „ Postgres “:

skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/operator/cloudnative-pg:v1.29.2_v0.35.0 docker://<internal-image-registry>/<internal-image-repository-path>/cloudnative-pg-operator:v1.29.2_v0.35.0
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/datastore/cnpg-containers:15_v0.40.0 docker://<internal-image-registry>/<internal-image-repository-path>/cnpg-containers:15_v0.40.0

Cassandra -Bilder kopieren:

skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/operator/cass-operator:1.30.3_v0.41.0 docker://<internal-image-registry>/<internal-image-repository-path>/cass-operator:1.30.3_v0.41.0
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/datastore/cassandra:4.1.11_v0.43.0 docker://<internal-image-registry>/<internal-image-repository-path>/cassandra:4.1.11_v0.43.0
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/datastore/system-logger:1.30.3_v0.24.0 docker://<internal-image-registry>/<internal-image-repository-path>/system-logger:1.30.3_v0.24.0
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/self-hosted-images/3rd-party/datastore/k8ssandra-client:0.8.14_v0.34.0 docker://<internal-image-registry>/<internal-image-repository-path>/k8ssandra-client:0.8.14_v0.34.0

ClickHouse -Bilder kopieren:

skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/clickhouse-operator:v1.2.39 docker://<internal-image-registry>/<internal-image-repository-path>/clickhouse-operator:v1.2.39
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/clickhouse:25.8.13.73-7-lts-ibm docker://<internal-image-registry>/<internal-image-repository-path>/clickhouse:25.8.13.73-7-lts-ibm

Kopieren Sie die Bilder „ cert-manager “:

skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/jetstack/cert-manager-controller:v1.20.3 docker://<internal-image-registry>/<internal-image-repository-path>/cert-manager-controller:v1.20.3
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/jetstack/cert-manager-webhook:v1.20.3 docker://<internal-image-registry>/<internal-image-repository-path>/cert-manager-webhook:v1.20.3
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/jetstack/cert-manager-cainjector:v1.20.3 docker://<internal-image-registry>/<internal-image-repository-path>/cert-manager-cainjector:v1.20.3
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/jetstack/cert-manager-acmesolver:v1.20.3 docker://<internal-image-registry>/<internal-image-repository-path>/cert-manager-acmesolver:v1.20.3
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/jetstack/cert-manager-startupapicheck:v1.20.3 docker://<internal-image-registry>/<internal-image-repository-path>/cert-manager-startupapicheck:v1.20.3

Kopieren Sie die Backend- und Operator-Images von „ Instana “:

while read p; do SOURCE=`echo "$p" | tac -s'/' | head -1`; echo $SOURCE; skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/backend/$SOURCE docker://<internal-image-registry>/<internal-image-repository-path>/$SOURCE; done<images.txt
OPERATOR_IMAGE=`echo "$(cat images.txt | tail -1)" | tac -s'/' |  head -1`
skopeo copy --dest-tls-verify=false docker://artifact-public.instana.io/infrastructure/$OPERATOR_IMAGE docker://<internal-image-registry>/<internal-image-repository-path>/$OPERATOR_IMAGE

Docker

Bilder ziehen:

docker pull artifact-public.instana.io/backend/acceptor:3.xxx.xxx–x
docker pull artifact-public.instana.io/clickhouse-operator:v1.2.39

Bilder neu taggen:

docker tag artifact-public.instana.io/backend/acceptor:3.xxx.xxx–x <internal-image-registry>/<internal-image-repository-path>/acceptor:3.xxx.xxx–x
docker tag artifact-public.instana.io/clickhouse-operator:v1.2.39 <internal-image-registry>/<internal-image-repository-path>/clickhouse-operator:v1.2.39

Bilder hochladen:

docker push <internal-image-registry>/<internal-image-repository-path>/acceptor:3.xxx.xxx–x
docker push <internal-image-registry>/<internal-image-repository-path>/clickhouse-operator:v1.2.39

Helm -Diagramme herunterladen:

helm -Repositorys hinzufügen.

helm repo add instana https://artifact-public.instana.io/artifactory/rel-helm-customer-virtual --username=_ --password=$DOWNLOAD_KEY

helm repo update

Helm -Diagramme herunterladen:

helm pull instana/ibm-clickhouse-operator --version=v1.2.0
helm pull instana/strimzi-kafka-operator --version=1.0.1
helm pull instana/eck-operator --version=3.4.1
helm pull instana/cloudnative-pg --version=0.29.0
helm pull instana/cass-operator --version=0.64.4
helm pull instana/cert-manager --version=v1.20.3

Datenspeicher installieren:

Installieren Sie „ Kafka “:

Installieren Sie Strimzi Kafka -Betreiber:

helm install strimzi ./$(ls | grep 'strimzi*' | head -1) --version 1.0.1 -n instana-kafka --create-namespace --set image.imagePullSecrets[0].name="instana-registry" --set image.registry=<internal-image-registry> --set image.name=strimzi --set image.tag=1.0.1_v0.33.0 --set kafka.image.registry=<internal-image-registry> --set kafka.image.name=kafka --set kafka.image.tag=1.0.1-kafka-4.1.2_v0.37.0

Erstellen Sie eine Datei „ YAML “ für den Broker. Zum Beispiel mit der kafka-broker.yaml Broker-Konfiguration.

apiVersion: kafka.strimzi.io/v1
kind: KafkaNodePool
metadata:
  name: kafka
  labels:
    strimzi.io/cluster: instana
spec:
  replicas: 3
  roles:
    - broker
  storage:
    type: jbod
    volumes:
      - id: 0
        type: persistent-claim
        size: 50Gi
        deleteClaim: true
  template:
    pod:
      tmpDirSizeLimit: 500Mi
      # Add the following Affinity snippet to schedule each pod on a different node.
      # affinity:
      #   podAntiAffinity:
      #     requiredDuringSchedulingIgnoredDuringExecution:
      #       - labelSelector:
      #           matchLabels:
      #             strimzi.io/pool-name: kafka
      #         topologyKey: "kubernetes.io/hostname"

Broker bereitstellen.

kubectl apply -f kafka-broker.yaml -n instana-kafka

Erstellen Sie eine Datei „ YAML “ für den Controller. Beispielsweise bei der Konfiguration kafka-controller.yaml des Controllers.

apiVersion: kafka.strimzi.io/v1
kind: KafkaNodePool
metadata:
  name: controller
  labels:
    strimzi.io/cluster: instana
spec:
  replicas: 3
  roles:
    - controller
  storage:
    type: persistent-claim
    size: 50Gi
    deleteClaim: true
  template:
    pod:
      tmpDirSizeLimit: 500Mi
      # Add the following Affinity snippet to schedule each pod on a different node.
      # affinity:
      #   podAntiAffinity:
      #     requiredDuringSchedulingIgnoredDuringExecution:
      #       - labelSelector:
      #           matchLabels:
      #             strimzi.io/pool-name: controller
      #         topologyKey: "kubernetes.io/hostname"

Controller bereitstellen.

kubectl apply -f kafka-controller.yaml -n instana-kafka

Erstellen Sie eine YAML-Datei. Beispielsweise mit der Konfiguration „ Kafkakafka.yaml “.

apiVersion: kafka.strimzi.io/v1
kind: Kafka
metadata:
  name: instana
  labels:
    strimzi.io/cluster: instana
  annotations:
    strimzi.io/node-pools: enabled
    strimzi.io/kraft:  enabled
spec:
  kafka: 
    Version: 4.1.2
    listeners:
      - name: scram
        port: 9092
        type: internal
        tls: false
        authentication:
          type: scram-sha-512
        configuration:
          useServiceDnsDomain: true
    authorization:
      type: simple
      superUsers:
        - strimzi-kafka-user
    config:
      offsets.topic.replication.factor: 3
      transaction.state.log.replication.factor: 3
      transaction.state.log.min.isr: 2
      default.replication.factor: 3
      min.insync.replicas: 2
      max.message.bytes: 52428800
      message.max.bytes: 52428800
      replica.fetch.max.bytes: 52428800
    template:
      pod:
        tmpDirSizeLimit: 100Mi
  entityOperator:
    template:
      pod:
        tmpDirSizeLimit: 100Mi
        # Add the following securityContext snippet for Kubernetes offerings other than OCP.
        # securityContext:
        #   runAsUser: 1000
        #   fsGroup: 1000
    userOperator:
      image: <internal-image-registry>/<internal-image-repository-path>/strimzi:1.0.1_v0.33.0

Kafka bereitstellen:

kubectl apply -f kafka.yaml -n instana-kafka
kubectl wait kafka/instana --for=condition=Ready --timeout=300s -n instana-kafka

Erstellen Sie einen SASL/SCRAM-Benutzer in „ Kafka “. Erstellen Sie eine Datei „ YAML “, beispielsweise strimzi-kafka-user.yaml:

apiVersion: kafka.strimzi.io/v1
kind: KafkaUser
metadata:
  name: strimzi-kafka-user
  labels:
    strimzi.io/cluster: instana
spec:
  authentication:
    type: scram-sha-512
  authorization:
    type: simple
    acls:
      - resource:
          type: topic
          name: '*'
          patternType: literal
        operation: All
        host: "*"
      - resource:
          type: group
          name: '*'
          patternType: literal
        operation: All
        host: "*"

Wenden Sie den Benutzer „ Kafka “ an:

kubectl apply -f strimzi-kafka-user.yaml -n instana-kafka
kubectl wait kafka/instana --for=condition=Ready --timeout=300s -n instana-kafka

Rufen Sie das Passwort des Benutzers „Strimzi- Kafka “ für die nächste Konfiguration ab:

kubectl get secret strimzi-kafka-user  -n instana-kafka --template='{{index .data.password | base64decode}}' && echo

Speichern Sie das abgerufene Passwort in der config.yaml Datei:

datastoreConfigs:
...
 kafkaConfig:
   adminUser: strimzi-kafka-user
   adminPassword: <RETRIEVED_FROM_SECRET>
   consumerUser: strimzi-kafka-user
   consumerPassword: <RETRIEVED_FROM_SECRET>
   producerUser: strimzi-kafka-user
   producerPassword: <RETRIEVED_FROM_SECRET>

Installieren Sie „ Elasticsearch “.

Installieren Sie den Operator „ Elasticsearch “. Wenn Sie einen Image-Pull-Secret erstellt haben, fügen Sie --set imagePullSecrets[0].name="<internal-image-registry-pull-secret>" zum folgenden Befehl hinzu.

helm install elastic-operator ./$(ls | grep 'eck*' | head -1) -n instana-elastic --create-namespace --version=3.4.1 --set image.repository=<internal-image-registry>/<internal-image-repository-path>/elasticsearch-operator --set image.tag=3.4.1_v0.34.0

Erstellen Sie ein Dienstkonto für „ ElasticSearch “.

kubectl create serviceaccount elasticsearch -n instana-elastic

Erstellen Sie eine Datei „ YAML “, beispielsweise mit der Konfiguration „ Elasticsearchelastic.yaml“.

apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: instana
spec:
  version: 8.19.18
  image: <internal-image-registry>/<internal-image-repository-path>/elasticsearch:8.19.18_v0.37.0
  nodeSets:
    - name: default
      count: 3
      config:
        node.roles:
          - master
          - data
          - ingest
        node.store.allow_mmap: false
      podTemplate:
        spec:
          serviceAccountName: elasticsearch
          imagePullSecrets:
            - name: instana-registry
      volumeClaimTemplates:
        - metadata:
            name: elasticsearch-data
          spec:
            accessModes:
              - ReadWriteOnce
            resources:
              requests:
                storage: 20Gi
  http:
    tls:
      selfSignedCertificate:
        disabled: true

Elasticsearch bereitstellen:

kubectl apply -f elastic.yaml -n instana-elastic
kubectl wait elasticsearch/instana --for=condition=ReconciliationComplete --timeout=300s -n instana-elastic

Standardmäßig wird ein Benutzer mit dem Namen „elastic“ mit einem zufällig generierten Passwort erstellt.

Rufen Sie das Passwort des Benutzers für die nächste Konfiguration ab:

kubectl get secret instana-es-elastic-user -n instana-elastic -o go-template='{{.data.elastic | base64decode}}' && echo

Ersetzen Sie <RETRIEVED_FROM_SECRET> in der config.yaml Datei durch das abgerufene Passwort:

datastoreConfigs:
...
 elasticsearchConfig:
   adminUser: elastic
   adminPassword: <RETRIEVED_FROM_SECRET>
   user: elastic
   password: <RETRIEVED_FROM_SECRET>
...

Installieren Sie „ Postgres “.

Für die Custom Edition auf einem Red Hat OpenShift -Cluster ermitteln Sie die Dateisystem-Gruppen-ID unter Red Hat OpenShift. Red Hat OpenShift erfordert, dass Dateisystemgruppen innerhalb eines für den Namespace spezifischen Wertebereichs liegen.
1. Wenn Sie die Custom Edition auf einem Cluster „ Red Hat OpenShift “ bereitstellen, rufen Sie den zulässigen Benutzerbereich ab.
```
kubectl get namespace instana-postgres -o yaml
 
```
Es wird eine Ausgabe ähnlich dem folgenden Beispiel angezeigt:
```
apiVersion: v1
kind: Namespace
metadata:
  annotations:
    .......
    openshift.io/sa.scc.uid-range: 1000750000/10000
  labels:
    kubernetes.io/metadata.name: instana-postgres
                .......
  name: instana-postgres
 
```
Die openshift.io/sa.scc.supplemental-groups Anmerkung enthält den Bereich der zulässigen IDs. Der Bereich 1000750000/10000 gibt 10.000 Werte an, die mit der ID 1000750000 beginnen und einen ID-Bereich von 1000750000 bis 1000760000 haben. Im Beispiel wird der Wert 1000750000 als Dateisystem-Gruppen-ID verwendet.

Installieren Sie den Operator „ Postgres “:

helm install cnpg cloudnative-pg-0.29.0.tgz --set image.repository=<internal-image-registry>/<internal-image-repository-path>/cloudnative-pg-operator --set image.tag=v1.29.2_v0.35.0 --version=0.29.0 -n instana-postgres

# Applicable for Openshift clusters
helm install cnpg cloudnative-pg-0.29.0.tgz --set image.repository=<internal-image-registry>/<internal-image-repository-path>/cloudnative-pg-operator --set image.tag=v1.29.2_v0.35.0 --version=0.29.0 --set containerSecurityContext.runAsUser=<UID from namespace> --set containerSecurityContext.runAsGroup=<UID from namespace> -n instana-postgres

Generieren Sie ein Passwort für den Datenspeicher „ Postgres “.

Ein zufälliges Passwort generieren:

openssl rand -base64 24 | tr -cd 'a-zA-Z0-9' | head -c32; echo

Erstellen Sie eine Datei, z. B postgres-secret.yaml.:

kind: Secret
apiVersion: v1
metadata:
  name: instanaadmin
type: Opaque
stringData:
  username: instanaadmin
  password: <user-generate-password> # Generated password

Wenden Sie die postgres-secrets.yaml Datei an:

kubectl apply -f postgres-secrets.yaml -n instana-postgres

Erstellen Sie eine Datei „ YAML “, beispielsweise postgres.yaml für die Datenspeicherkonfiguration:

apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: postgres
spec:
  instances: 3
  imageName: <internal-image-registry>/<internal-image-repository-path>/cnpg-containers:15_v0.40.0
  imagePullPolicy: IfNotPresent
  imagePullSecrets:
    - name: instana-registry
  postgresql:
    parameters:
      shared_buffers: 32MB
      pg_stat_statements.track: all
      auto_explain.log_min_duration: '10s'
    pg_hba:
      - local     all          all                            trust
      - host      all          all          0.0.0.0/0         md5
      - local     replication  standby                        trust
      - hostssl   replication  standby      all               md5
      - hostnossl all          all          all               reject
      - hostssl   all          all          all               md5
  managed:
    roles:
    - name: instanaadmin
      login: true
      superuser: true
      createdb: true
      createrole: true
      passwordSecret:
        name: instanaadmin
  bootstrap:
    initdb:
      database: instanaadmin
      owner: instanaadmin
      secret:
        name: instanaadmin
  superuserSecret:
    name: instanaadmin
  storage:
    size: 1Gi

Postgres bereitstellen:

kubectl apply -f postgres.yaml -n instana-postgres

Speichern Sie das generierte Passwort in der config.yaml Datei:

datastoreConfigs:
...
  postgresConfigs:
    - user: instanaadmin
      password: <USER_GENERATED_PASSWORD>
      adminUser: instanaadmin
      adminPassword: <USER_GENERATED_PASSWORD>
...

Installieren Sie „ Cassandra “.

Installieren Sie Cert-Manager: Cassandra verwendet Cert-Manager zur Generierung von Zertifikaten.

helm install cert-manager cert-manager-v1.20.3.tgz --namespace cert-manager --create-namespace --version v1.20.3 --set installCRDs=true --set prometheus.enabled=false --set image.repository=<internal-image-registry>/<internal-image-repository-path>/cert-manager-controller --set webhook.image.repository=<internal-image-registry>/<internal-image-repository-path>/cert-manager-webhook --set cainjector.image.repository=<internal-image-registry>/<internal-image-repository-path>/cert-manager-cainjector --set acmesolver.image.repository=<internal-image-registry>/<internal-image-repository-path>/cert-manager-acmesolver --set startupapicheck.image.repository=<internal-image-registry>/<internal-image-repository-path>/cert-manager-startupapicheck

Wenn Sie die Custom Edition auf einem Cluster „ Red Hat OpenShift “ bereitstellen, erstellen Sie eine Datei, z. B cassandra-scc.yaml.:

# Applicable for Openshift clusters
apiVersion: security.openshift.io/v1
kind: SecurityContextConstraints
metadata:
  name: cassandra-scc
runAsUser:
  type: MustRunAs
  uid: 999
seLinuxContext:
  type: RunAsAny
fsGroup:
  type: RunAsAny
allowHostDirVolumePlugin: false
allowHostNetwork: true
allowHostPorts: true
allowPrivilegedContainer: false
allowHostIPC: true
allowHostPID: true
readOnlyRootFilesystem: false
users:
  - system:serviceaccount:instana-cassandra:cass-operator
  - system:serviceaccount:instana-cassandra:cassandra

Die Datei anwenden:

# Applicable for Openshift clusters
kubectl apply -f cassandra-scc.yaml

Cass Operator installieren:

helm install cass-operator cass-operator-0.64.4.tgz -n instana-cassandra --create-namespace --version=0.64.4 --set securityContext.runAsGroup=999 --set securityContext.runAsUser=999 --set image.registry=<internal-image-registry> --set image.repository=cass-operator --set image.tag=1.30.3_v0.41.0 --set appVersion=1.30.3 --set global.imageConfig.images.system-logger.repository=system-logger --set global.imageConfig.images.system-logger.tag=1.30.3_v0.24.0 --set global.imageConfig.images.k8ssandra-client.repository=k8ssandra-client --set global.imageConfig.images.k8ssandra-client.tag=0.8.14_v0.34.0

Erstellen Sie eine Datei, z. B cassandra.yaml.:

apiVersion: cassandra.datastax.com/v1beta1
kind: CassandraDatacenter
metadata:
  name: cassandra
spec:
  clusterName: instana
  serverType: cassandra
  serverImage: <internal-image-registry>/<internal-image-repository-path>/cassandra:4.1.11_v0.43.0
  k8ssandraClientImage: <internal-image-registry>/<internal-image-repository-path>/k8ssandra-client:0.8.14_v0.34.0
  systemLoggerImage: <internal-image-registry>/<internal-image-repository-path>/system-logger:1.30.3_v0.24.0
  serverVersion: 4.1.11
  podTemplateSpec:
    spec:
      serviceAccountName: cassandra
      imagePullSecrets:
        - name: instana-registry
      containers:
      - name: cassandra
  managementApiAuth:
    insecure: {}
  size: 3
  allowMultipleNodesPerWorker: false
  resources:
    requests:
      cpu: 2000m
      memory: 8Gi
    limits:
      cpu: 4000m
      memory: 16Gi
  storageConfig:
    cassandraDataVolumeClaimSpec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 30Gi
  config:
    jvm-server-options:
      initial_heap_size: "4G"
      max_heap_size: "8G"
      additional-jvm-opts:
        - -Dcassandra.allow_unsafe_aggressive_sstable_expiration=true
    cassandra-yaml:
      authenticator: org.apache.cassandra.auth.PasswordAuthenticator
      authorizer: org.apache.cassandra.auth.CassandraAuthorizer
      role_manager: org.apache.cassandra.auth.CassandraRoleManager
      memtable_flush_writers: 8
      auto_snapshot: false
      gc_warn_threshold_in_ms: 10000
      otc_coalescing_strategy: DISABLED
      memtable_allocation_type: offheap_objects
      num_tokens: 256
      drop_compact_storage_enabled: true

Cassandra bereitstellen:
```
kubectl apply -f cassandra.yaml -n instana-cassandra
 
```
Standardmäßig erstellt das Cassandra Rechenzentrum einen Superuser, z. B. Clustername-superuser. clusterName ist der Wert, der in .spec.clusterName der cassandra.yaml Datei angegeben ist. Der geheime Name lautet instana-superuser.

Passwort abrufen für instana-superuser:

kubectl get secret instana-superuser -n instana-cassandra --template='{{index .data.password | base64decode}}' && echo

Ersetzen Sie in der config.yaml<RETRIEVED_FROM_SECRET> Datei durch das abgerufene Passwort:

datastoreConfigs:
  ...
  cassandraConfigs:
    - user: instana-superuser
      password: <RETRIEVED_FROM_SECRET>
      adminUser: instana-superuser
      adminPassword: <RETRIEVED_FROM_SECRET>
  ...

ClickHouse: installieren

Wenn Sie die Custom Edition auf einem Cluster „ Red Hat OpenShift “ bereitstellen, erstellen Sie eine Datei, z. B clickhouse-scc.yaml.:

apiVersion: security.openshift.io/v1
kind: SecurityContextConstraints
metadata:
  name: clickhouse-scc
runAsUser:
  type: RunAsAny
seLinuxContext:
  type: RunAsAny
fsGroup:
  type: RunAsAny
supplementalGroups:
  type: RunAsAny
allowHostDirVolumePlugin: false
allowHostNetwork: true
allowHostPorts: true
allowPrivilegedContainer: false
allowHostIPC: true
allowHostPID: true
readOnlyRootFilesystem: false
users:
  - system:serviceaccount:instana-clickhouse:clickhouse-operator
  - system:serviceaccount:instana-clickhouse:clickhouse-operator-ibm-clickhouse-operator
  - system:serviceaccount:instana-clickhouse:clickhouse
  - system:serviceaccount:instana-clickhouse:clickhousekeeper

Die Datei anwenden:

# Applicable for Openshift cluster
kubectl apply -f clickhouse-scc.yaml

Installieren Sie den Operator „ ClickHouse “:

helm install clickhouse-operator ibm-clickhouse-operator-v1.2.39.tgz -n instana-clickhouse --version=v1.2.0 --set operator.image.repository=<internal-image-registry>/<internal-image-repository-path>/clickhouse-operator --set operator.image.tag=v1.2.39

Erstellen Sie eine Datei „ YAML “, beispielsweise „ clickhouse_keeper.yaml “, mit der ClickHouseKeeperInstallation Ressourcendefinition.

apiVersion: "clickhouse-keeper.altinity.com/v1"
kind: "ClickHouseKeeperInstallation"
metadata:
  name: clickhouse-keeper
  namespace: instana-clickhouse
spec:
  configuration:
    clusters:
      - name: "local"
        layout:
          replicasCount: 3
    settings:
        logger/level: "information"
        logger/console: "true"
        listen_host: "0.0.0.0"
        keeper_server/snapshot_storage_path: /var/lib/clickhouse-keeper/coordination/snapshots/store
        keeper_server/log_storage_path: /var/lib/clickhouse-keeper/coordination/logs/store
        keeper_server/storage_path: /var/lib/clickhouse-keeper/
        keeper_server/tcp_port: "2181"
        keeper_server/four_letter_word_white_list: "*"
        keeper_server/coordination_settings/raft_logs_level: "information"
        keeper_server/raft_configuration/server/port: "9444"
        prometheus/endpoint: "/metrics"
        prometheus/port: "7000"
        prometheus/metrics: "true"
        prometheus/events: "true"
        prometheus/asynchronous_metrics: "true"
        prometheus/status_info: "false"
        zookeeper/node/host: "localhost"
        zookeeper/node/port: "9181"
  templates:
    podTemplates:
      - name: clickhouse-keeper
        spec:
          # Add the following Affinity snippet to schedule each pod on a different node.
          # affinity:
          #   podAntiAffinity:
          #     requiredDuringSchedulingIgnoredDuringExecution:
          #       - labelSelector:
          #           matchLabels:
          #             app: clickhouse-keeper
          #         topologyKey: "kubernetes.io/hostname"
          containers:
            - name: clickhouse-keeper
              imagePullPolicy: IfNotPresent
              image: <internal-image-registry>/<internal-image-repository-path>/clickhouse:25.8.13.73-7-lts-ibm
              command:
                - clickhouse-keeper
                - --config-file=/etc/clickhouse-keeper/keeper_config.xml
              resources:
                requests:
                  memory: "1Gi"
          serviceAccountName: clickhousekeeper
          imagePullSecrets:
            - name: instana-registry
          securityContext:
            fsGroup: 0
            runAsGroup: 0
            runAsUser: 1001
          initContainers:
            - name: server-id-injector
              imagePullPolicy: IfNotPresent
              image:  <internal-image-registry>/<internal-image-repository-path>/clickhouse:25.8.13.73-7-lts-ibm
    volumeClaimTemplates:
      - name: log-storage-path
        spec:
          storageClassName: <storage_class_name>
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 20Gi
      - name: snapshot-storage-path
        spec:
          storageClassName: <storage_class_name>
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 20Gi

ClickHouseKeeper bereitstellen.

kubectl apply -f clickhouse_keeper.yaml -n instana-clickhouse

Erstellen Sie eine Datei, z. B clickhouse_installation.yaml.:

apiVersion: "clickhouse.altinity.com/v1"
kind: "ClickHouseInstallation"
metadata:
  name: "instana"
spec:
  defaults:
    templates:
      dataVolumeClaimTemplate: instana-clickhouse-data-volume
      logVolumeClaimTemplate: instana-clickhouse-log-volume
      serviceTemplate: service-template
  configuration:
    files:
      config.d/storage.xml: |
        <clickhouse>
          <storage_configuration>
            <disks>
              <default/>
              <cold_disk>
                <path>/var/lib/clickhouse-cold/</path>
              </cold_disk>
            </disks>
            <policies>
              <logs_policy>
                <volumes>
                  <data>
                    <disk>default</disk>
                  </data>
                  <cold>
                    <disk>cold_disk</disk>
                  </cold>
                </volumes>
              </logs_policy>
              <logs_policy_v4>
                <volumes>
                  <tier1>
                    <disk>default</disk>
                  </tier1>
                  <tier2>
                    <disk>cold_disk</disk>
                  </tier2>
                </volumes>
              </logs_policy_v4>
            </policies>
          </storage_configuration>
        </clickhouse>
    clusters:
      - name: local
        templates:
          podTemplate: clickhouse
        layout:
          shardsCount: 1
          replicasCount: 2 # The replication count of 2 is fixed for Instana backend installations
        schemaPolicy:
          replica: None
          shard: None
    zookeeper:
      nodes:
        - host: clickhouse-keeper-headless.instana-clickhouse  #if you use ClickhouseKeeper
      # - host: instana-zookeeper-headless.instana-clickhouse
    profiles:
      default/prefer_localhost_replica: 1
      default/max_memory_usage: 10000000000 # If memory limits are set, this value must be adjusted according to the limits.
      default/joined_subquery_requires_alias: 0
      default/max_execution_time: 100
      default/max_query_size: 1048576
      default/use_uncompressed_cache: 0
      default/enable_http_compression: 1
      default/load_balancing: random
      default/background_pool_size: 32
      default/background_schedule_pool_size: 32
      default/distributed_directory_monitor_split_batch_on_failure: 1
      default/distributed_directory_monitor_batch_inserts: 1
      default/insert_distributed_sync: 1
      default/log_queries: 1
      default/log_query_views: 1
      default/max_threads: 16
      default/allow_experimental_database_replicated: 1
      default/allow_experimental_analyzer: 0
    quotas:
      default/interval/duration: 3600
      default/interval/queries: 0
      default/interval/errors: 0
      default/interval/result_rows: 0
      default/interval/read_rows: 0
      default/interval/execution_time: 0
    settings:
      remote_servers/all-sharded/secret: clickhouse-default-pass
      remote_servers/all-replicated/secret: clickhouse-default-pass
      remote_servers/local/secret: clickhouse-default-pass
      max_concurrent_queries: 200
      max_table_size_to_drop: 0
      max_partition_size_to_drop: 0
    users:
      default/password: "clickhouse-default-pass"
      clickhouse-user/networks/ip: "::/0"
      clickhouse-user/password: "clickhouse-pass"
      # Or
      # Generate password and the corresponding SHA256 hash with:
      # $ PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-'
      # 6edvj2+d                                                          <- first line is the password
      # a927723f4a42cccc50053e81bab1fcf579d8d8fb54a3ce559d42eb75a9118d65  <- second line is the corresponding SHA256 hash
      # clickhouse-user/password_sha256_hex: "a927723f4a42cccc50053e81bab1fcf579d8d8fb54a3ce559d42eb75a9118d65"
      # Or
      # Generate password and the corresponding SHA1 hash with:
      # $ PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha1sum | tr -d '-' | xxd -r -p | sha1sum | tr -d '-'
      # LJfoOfxl                                  <- first line is the password, put this in the k8s secret
      # 3435258e803cefaab7db2201d04bf50d439f6c7f  <- the corresponding double SHA1 hash, put this below
      # clickhouse-user/password_double_sha1_hex: "3435258e803cefaab7db2201d04bf50d439f6c7f"
  templates:
    podTemplates:
      - name: clickhouse
        spec:
          # Add the following Affinity snippet to schedule each pod on a different node.
          # affinity:
          #   podAntiAffinity:
          #     requiredDuringSchedulingIgnoredDuringExecution:
          #       - labelSelector:
          #           matchExpressions:
          #             - key: "clickhouse.altinity.com/app"
          #               operator: In
          #               values:
          #                 - "chop"
          #         topologyKey: "kubernetes.io/hostname"
          containers:
            - name: instana-clickhouse
              image: <internal-image-registry>/<internal-image-repository-path>/clickhouse:25.8.13.73-7-lts-ibm
              command:
                - clickhouse-server
                - --config-file=/etc/clickhouse-server/config.xml
              volumeMounts:
                - mountPath: /var/lib/clickhouse-cold/
                  name: instana-clickhouse-data-cold-volume
            - name: clickhouse-log
              image: <internal-image-registry>/<internal-image-repository-path>/clickhouse:25.8.13.73-7-lts-ibm
              args:
                - while true; do sleep 30; done;
              command:
                - /bin/sh
                - -c
                - --
          serviceAccountName: clickhouse
          imagePullSecrets:
            - name: instana-registry
          securityContext:
            fsGroup: 0
            runAsGroup: 0
            runAsUser: 1001
        # Optional - uncomment the following lines if resources need to be specifically defined for the clickhouse pods. The  following values are for example only.
        # resources:
        #   limits:
        #     cpu: "4"
        #     memory: 4Gi
        #   requests:
        #     cpu: "1"
        #     memory: 2Gi
  volumeClaimTemplates:
    - name: instana-clickhouse-data-volume
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 100Gi
    - name: instana-clickhouse-log-volume
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 1Gi
    - name: instana-clickhouse-data-cold-volume
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 100Gi
  serviceTemplates:
    - name: service-template
      generateName: "clickhouse-{chi}"
      spec:
        ports:
          - name: http
            port: 8123
          - name: tcp
            port: 9000
        type: ClusterIP

Aktualisieren Sie das zookeeper.nodes.host Feld mit dem Hostnamen Ihres Clickhouse Keeper-Clusters.

Standardmäßig werden clickhouse-pass und zu „ clickhouse-userClickHouse “ hinzugefügt.

ClickHouse bereitstellen.

kubectl apply -f clickhouse_installation.yaml -n instana-clickhouse

Ersetzen Sie in der config.yaml<USER_GENERATED_PASSWORD> Datei durch das abgerufene Passwort:

Hinweis:
Sie müssen dasselbe zufällige Passwort verwenden, das Sie zuvor bei der Online-Installation von ClickHouse oder der Offline-Installation von ClickHouse erstellt haben. Verwenden Sie nicht das entsprechende Passwort für den Hash „ SHA256 “.
```
datastoreConfigs:
  ...
  clickhouseConfigs:
    - user: clickhouse-user
      password: <USER_GENERATED_PASSWORD>
      adminUser: clickhouse-user
      adminPassword: <USER_GENERATED_PASSWORD>
   ...
 
```

Optional: Installieren Sie BeeInstana, siehe Installation des BeeInstana Kubernetes Operator offline (air-gapped).

Installieren Sie den Enterprise-Operator „ Instana “. Erstellen und konfigurieren Sie eine Wertedatei zur Verwendung in der Instana-Operator Datei:

Erstellen Sie eine Wertedatei, siehe Erstellen der Wertedatei.

Fügen Sie die folgenden Zeilen zur Werte-Datei hinzu:

operator:
  image:
    registry: <internal-image-registry>
    repository: <internal-image-repository-path>/instana-enterprise-operator
webhook:
  image:
    registry: <internal-image-registry>
    repository: <internal-image-repository-path>/instana-enterprise-operator-webhook
imagePullSecrets:
  - name: instana-registry

Wenden Sie die Änderungen an:

kubectl instana operator apply -n instana-operator  --values <pathtoFile>/values.yaml

Überprüfen Sie die Bereitstellung des Instana Enterprise-Operators:
```
kubectl get all -n instana-operator
 
```

Instana -Kernfunktionen bereitstellen.

Kerngeheimnisse erstellen CoreSecret.

Erstellen Sie eine Datei, z. B., core.yaml um den Kern bereitzustellen CreatingACore.

apiVersion: instana.io/v1beta2
kind: Core
metadata:
  name: instana-core
spec:
  ...
  gatewayConfig:
    controller:
      imageConfig:
        registry: <internal-image-registry>
    gateway:
      imageConfig:
        registry: <internal-image-registry>
  imageConfig:
    registry: <internal-image-registry>
    repository: <internal-image-repository-path>
  imagePullSecrets:
    - name: instana-registry
  ...

Instana -Einheit einsetzen.
1. Holen Sie sich den Lizenzschlüssel DownloadingTheLicenseFile.
```
kubectl instana license download --sales-key <redacted>
 
```
2. Erstellen Sie Geheimnisse für Einheiten UnitSecret.
3. Erstellen Sie eine Datei, z. B. units.yaml to deploy unit CreateAUnitAndTenant.