Nexus Kubernetes-cluster bewaken

Elk Nexus Kubernetes-cluster bestaat uit meerdere lagen:

• Virtuele machines (VM's)
• Kubernetes-laag
• Toepassingspods

Afbeelding: Voorbeeld van Nexus Kubernetes-cluster

Op een exemplaar worden Nexus Kubernetes-clusters geleverd met een optioneleOplossing voor waarneembaarheid van Container Insights . Container Insights legt de logboeken en metrische gegevens van Nexus Kubernetes-clusters en -workloads vast. Het is uitsluitend uw beoordelingsvermogen om deze hulpprogramma's in te schakelen of uw eigen telemetriestack te implementeren.

Het Nexus Kubernetes-cluster met het azure-bewakingsprogramma ziet er als volgt uit:

Afbeelding: Nexus Kubernetes-cluster met bewakingshulpprogramma's

Onboarding van extensies met CLI met behulp van verificatie van beheerde identiteiten

Documentatie voor het starten met Azure CLI, het installeren ervan op meerdere besturingssystemen en het installeren van CLI-extensies.

Installeer de nieuwste versie van de benodigde CLI-extensies.

Nexus Kubernetes-cluster bewaken - VM-laag

Deze handleiding bevat stappen en hulpprogrammascripts voor Arc om de virtuele machines van het Nexus Kubernetes-cluster te verbinden met Azure en bewakingsagents in te schakelen voor het verzamelen van systeemlogboeken van deze VM's met behulp van de Azure Monitoring Agent. In de instructies worden details vastgelegd over het instellen van logboekgegevensverzameling in een Log Analytics-werkruimte.

De volgende bronnen bieden u ondersteuning:

• arc-connect.env: gebruik dit sjabloonbestand om omgevingsvariabelen te maken die nodig zijn voor opgenomen scripts

export SUBSCRIPTION_ID=""
export SERVICE_PRINCIPAL_ID=""
export SERVICE_PRINCIPAL_SECRET=""
export RESOURCE_GROUP=""
export TENANT_ID=""
export LOCATION=""
export INSTALL_AZURE_MONITOR_AGENT="true"
export PROXY_URL=""
export NAMESPACE=""
export AZURE_MONITOR_AGENT_VERSION="1.24.2"
export CONNECTEDMACHINE_AZCLI_VERSION="0.6.0"

• dcr.sh: gebruik dit script om een DCR (Data Collection Rule) te maken om syslog-verzameling te configureren

#!/bin/bash
set -e

SUBSCRIPTION_ID="${SUBSCRIPTION_ID:?SUBSCRIPTION_ID must be set}"
SERVICE_PRINCIPAL_ID="${SERVICE_PRINCIPAL_ID:?SERVICE_PRINCIPAL_ID must be set}"
SERVICE_PRINCIPAL_SECRET="${SERVICE_PRINCIPAL_SECRET:?SERVICE_PRINCIPAL_SECRET must be set}"
RESOURCE_GROUP="${RESOURCE_GROUP:?RESOURCE_GROUP must be set}"
TENANT_ID="${TENANT_ID:?TENANT_ID must be set}"
LOCATION="${LOCATION:?LOCATION must be set}"
LAW_RESOURCE_ID="${LAW_RESOURCE_ID:?LAW_RESOURCE_ID must be set}"
DCR_NAME=${DCR_NAME:-${RESOURCE_GROUP}-syslog-dcr}

az login --service-principal -u "${SERVICE_PRINCIPAL_ID}" -p "${SERVICE_PRINCIPAL_SECRET}" -t "${TENANT_ID}"

az account set -s "${SUBSCRIPTION_ID}"

az extension add --name monitor-control-service

RULEFILE=$(mktemp)
tee "${RULEFILE}" <<EOF
{
  "location": "${LOCATION}",
  "properties": {
    "dataSources": {
      "syslog": [
        {
          "name": "syslog",
          "streams": [
            "Microsoft-Syslog"
          ],
          "facilityNames": [
            "auth",
            "authpriv",
            "cron",
            "daemon",
            "mark",
            "kern",
            "local0",
            "local1",
            "local2",
            "local3",
            "local4",
            "local5",
            "local6",
            "local7",
            "lpr",
            "mail",
            "news",
            "syslog",
            "user",
            "uucp"
          ],
          "logLevels": [
            "Info",
            "Notice",
            "Warning",
            "Error",
            "Critical",
            "Alert",
            "Emergency"
          ]
        }
      ]
    },
    "destinations": {
      "logAnalytics": [
        {
          "workspaceResourceId": "${LAW_RESOURCE_ID}",
          "name": "centralWorkspace"
        }
      ]
    },
    "dataFlows": [
      {
        "streams": [
          "Microsoft-Syslog"
        ],
        "destinations": [
          "centralWorkspace"
        ]
      }
    ]
  }
}

EOF

az monitor data-collection rule create --name "${DCR_NAME}" --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --rule-file "${RULEFILE}" -o tsv --query id

rm -rf "${RULEFILE}"

• assign.sh: gebruik het script om een beleid te maken om de DCR te koppelen aan alle servers met Arc in een resourcegroep

#!/bin/bash
set -e

SUBSCRIPTION_ID="${SUBSCRIPTION_ID:?SUBSCRIPTION_ID must be set}"
SERVICE_PRINCIPAL_ID="${SERVICE_PRINCIPAL_ID:?SERVICE_PRINCIPAL_ID must be set}"
SERVICE_PRINCIPAL_SECRET="${SERVICE_PRINCIPAL_SECRET:?SERVICE_PRINCIPAL_SECRET must be set}"
RESOURCE_GROUP="${RESOURCE_GROUP:?RESOURCE_GROUP must be set}"
TENANT_ID="${TENANT_ID:?TENANT_ID must be set}"
LOCATION="${LOCATION:?LOCATION must be set}"
DCR_NAME=${DCR_NAME:-${RESOURCE_GROUP}-syslog-dcr}
POLICY_NAME=${POLICY_NAME:-${DCR_NAME}-policy}

az login --service-principal -u "${SERVICE_PRINCIPAL_ID}" -p "${SERVICE_PRINCIPAL_SECRET}" -t "${TENANT_ID}"

az account set -s "${SUBSCRIPTION_ID}"

DCR=$(az monitor data-collection rule show --name "${DCR_NAME}" --resource-group "${RESOURCE_GROUP}" -o tsv --query id)

PRINCIPAL=$(az policy assignment create \
  --name "${POLICY_NAME}" \
  --display-name "${POLICY_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --location "${LOCATION}" \
  --policy "d5c37ce1-5f52-4523-b949-f19bf945b73a" \
  --assign-identity \
  -p "{\"dcrResourceId\":{\"value\":\"${DCR}\"}}" \
  -o tsv --query identity.principalId)

required_roles=$(az policy definition show -n "d5c37ce1-5f52-4523-b949-f19bf945b73a" --query policyRule.then.details.roleDefinitionIds -o tsv)
for roleId in $(echo "$required_roles"); do
  az role assignment create \
    --role "${roleId##*/}" \
    --assignee-object-id "${PRINCIPAL}" \
    --assignee-principal-type "ServicePrincipal" \
    --scope /subscriptions/"$SUBSCRIPTION_ID"/resourceGroups/"$RESOURCE_GROUP"
done

• install.sh: Installeer Azure Monitoring Agent op elke VM om bewakingsgegevens van virtuele Azure-machines te verzamelen.

#!/bin/bash
set -e

function create_secret() {
  kubectl apply -f - -n "${NAMESPACE}" <<EOF
apiVersion: v1
kind: Secret
metadata:
  name: naks-vm-telemetry
type: Opaque
stringData:
  SUBSCRIPTION_ID: "${SUBSCRIPTION_ID}"
  SERVICE_PRINCIPAL_ID: "${SERVICE_PRINCIPAL_ID}"
  SERVICE_PRINCIPAL_SECRET: "${SERVICE_PRINCIPAL_SECRET}"
  RESOURCE_GROUP: "${RESOURCE_GROUP}"
  TENANT_ID: "${TENANT_ID}"
  LOCATION: "${LOCATION}"
  PROXY_URL: "${PROXY_URL}"
  INSTALL_AZURE_MONITOR_AGENT: "${INSTALL_AZURE_MONITOR_AGENT}"
  VERSION: "${AZURE_MONITOR_AGENT_VERSION}"
  CONNECTEDMACHINE_AZCLI_VERSION: "${CONNECTEDMACHINE_AZCLI_VERSION}"
EOF
}

function create_daemonset() {
  kubectl apply -f - -n "${NAMESPACE}" <<EOF
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: naks-vm-telemetry
  labels:
    k8s-app: naks-vm-telemetry
spec:
  selector:
    matchLabels:
      name: naks-vm-telemetry
  template:
    metadata:
      labels:
        name: naks-vm-telemetry
    spec:
      hostNetwork: true
      hostPID: true
      containers:
        - name: naks-vm-telemetry
          image: mcr.microsoft.com/oss/mirror/docker.io/library/ubuntu:20.04
          env:
            - name: SUBSCRIPTION_ID
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: SUBSCRIPTION_ID
            - name: SERVICE_PRINCIPAL_ID
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: SERVICE_PRINCIPAL_ID
            - name: SERVICE_PRINCIPAL_SECRET
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: SERVICE_PRINCIPAL_SECRET
            - name: RESOURCE_GROUP
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: RESOURCE_GROUP
            - name: TENANT_ID
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: TENANT_ID
            - name: LOCATION
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: LOCATION
            - name: PROXY_URL
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: PROXY_URL
            - name: INSTALL_AZURE_MONITOR_AGENT
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: INSTALL_AZURE_MONITOR_AGENT
            - name: VERSION
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: VERSION
            - name: CONNECTEDMACHINE_AZCLI_VERSION
              valueFrom:
                secretKeyRef:
                  name: naks-vm-telemetry
                  key: CONNECTEDMACHINE_AZCLI_VERSION
          securityContext:
            privileged: true
          command:
            - /bin/bash
            - -c
            - |
              set -e
              WORKDIR=\$(nsenter -t1 -m -u -n -i mktemp -d)
              trap 'nsenter -t1 -m -u -n -i rm -rf "\${WORKDIR}"; echo "Azure Monitor Configuration Failed"' ERR
              nsenter -t1 -m -u -n -i mkdir -p "\${WORKDIR}"/telemetry

              nsenter -t1 -m -u -n -i tee "\${WORKDIR}"/telemetry/telemetry_common.py > /dev/null <<EOF
              #!/usr/bin/python3
              import json
              import logging
              import os
              import socket
              import subprocess
              import sys

              arc_config_file = "\${WORKDIR}/telemetry/arc-connect.json"


              class AgentryResult:
                  CONNECTED = "Connected"
                  CREATING = "Creating"
                  DISCONNECTED = "Disconnected"
                  FAILED = "Failed"
                  SUCCEEDED = "Succeeded"


              class OnboardingMessage:
                  COMPLETED = "Onboarding completed"
                  STILL_CREATING = "Azure still creating"
                  STILL_TRYING = "Service still trying"


              def get_logger(logger_name):
                  logger = logging.getLogger(logger_name)
                  logger.setLevel(logging.DEBUG)
                  handler = logging.StreamHandler(stream=sys.stdout)
                  format = logging.Formatter(fmt="%(name)s - %(levelname)s - %(message)s")
                  handler.setFormatter(format)
                  logger.addHandler(handler)
                  return logger


              def az_cli_cm_ext_install(logger, config):
                  logger.info("Install az CLI connectedmachine extension")
                  proxy_url = config.get("PROXY_URL")
                  if proxy_url is not None:
                      os.environ["HTTP_PROXY"] = proxy_url
                      os.environ["HTTPS_PROXY"] = proxy_url
                  cm_azcli_version = config.get("CONNECTEDMACHINE_AZCLI_VERSION")
                  logger.info("Install az CLI connectedmachine extension: {cm_azcli_version}")
                  ext_cmd = f'/usr/bin/az extension add --name connectedmachine --version "{cm_azcli_version}" --yes'
                  run_cmd(logger, ext_cmd)


              def get_cm_properties(logger, config):
                  hostname = socket.gethostname()
                  resource_group = config.get("RESOURCE_GROUP")

                  logger.info(f"Getting arc enrollment properties for {hostname}...")

                  az_login(logger, config)

                  property_cmd = f'/usr/bin/az connectedmachine show --machine-name "{hostname}" --resource-group "{resource_group}"'

                  try:
                      raw_property = run_cmd(logger, property_cmd)
                      cm_json = json.loads(raw_property.stdout)
                      provisioning_state = cm_json["provisioningState"]
                      status = cm_json["status"]
                  except:
                      logger.warning("Connectedmachine not yet present")
                      provisioning_state = "NOT_PROVISIONED"
                      status = "NOT_CONNECTED"
                  finally:
                      az_logout(logger)

                  logger.info(
                      f'Connected machine "{hostname}" provisioningState is "{provisioning_state}" and status is "{status}"'
                  )

                  return provisioning_state, status


              def get_cm_extension_state(logger, config, extension_name):
                  resource_group = config.get("RESOURCE_GROUP")
                  hostname = socket.gethostname()

                  logger.info(f"Getting {extension_name} state for {hostname}...")

                  az_login(logger, config)

                  state_cmd = f'/usr/bin/az connectedmachine extension show --name "{extension_name}" --machine-name "{hostname}" --resource-group "{resource_group}"'

                  try:
                      raw_state = run_cmd(logger, state_cmd)
                      cme_json = json.loads(raw_state.stdout)
                      provisioning_state = cme_json["provisioningState"]
                  except:
                      logger.warning("Connectedmachine extension not yet present")
                      provisioning_state = "NOT_PROVISIONED"
                  finally:
                      az_logout(logger)

                  logger.info(
                      f'Connected machine "{hostname}" extenstion "{extension_name}" provisioningState is "{provisioning_state}"'
                  )

                  return provisioning_state


              def run_cmd(logger, cmd, check_result=True, echo_output=True):
                  res = subprocess.run(
                      cmd,
                      shell=True,
                      stdout=subprocess.PIPE,
                      stderr=subprocess.PIPE,
                      universal_newlines=True,
                  )

                  if res.stdout:
                      if echo_output:
                          logger.info(f"[OUT] {res.stdout}")

                  if res.stderr:
                      if echo_output:
                          logger.info(f"[ERR] {res.stderr}")

                  if check_result:
                      res.check_returncode()

                  return res  # can parse out res.stdout and res.returncode


              def az_login(logger, config):
                  logger.info("Login to Azure account...")
                  proxy_url = config.get("PROXY_URL")
                  if proxy_url is not None:
                      os.environ["HTTP_PROXY"] = proxy_url
                      os.environ["HTTPS_PROXY"] = proxy_url

                  service_principal_id = config.get("SERVICE_PRINCIPAL_ID")
                  service_principal_secret = config.get("SERVICE_PRINCIPAL_SECRET")
                  tenant_id = config.get("TENANT_ID")
                  subscription_id = config.get("SUBSCRIPTION_ID")
                  cmd = f'/usr/bin/az login --service-principal --username "{service_principal_id}" --password "{service_principal_secret}" --tenant "{tenant_id}"'
                  run_cmd(logger, cmd)
                  logger.info(f"Set Subscription...{subscription_id}")
                  set_sub = f'/usr/bin/az account set --subscription "{subscription_id}"'
                  run_cmd(logger, set_sub)


              def az_logout(logger):
                  logger.info("Logout of Azure account...")
                  run_cmd(logger, "/usr/bin/az logout --verbose", check_result=False)

              EOF

              nsenter -t1 -m -u -n -i tee "\${WORKDIR}"/telemetry/setup_azure_monitor_agent.py > /dev/null <<EOF
              #!/usr/bin/python3
              import json
              import os
              import socket
              import time

              import telemetry_common


              def run_install(logger, ama_config):
                  logger.info("Install Azure Monitor agent...")
                  resource_group = ama_config.get("RESOURCE_GROUP")
                  location = ama_config.get("LOCATION")
                  proxy_url = ama_config.get("PROXY_URL")
                  hostname = socket.gethostname()
                  if proxy_url is not None:
                      os.environ["HTTP_PROXY"] = proxy_url
                      os.environ["HTTPS_PROXY"] = proxy_url
                      settings = (
                          '{"proxy":{"mode":"application","address":"'
                          + proxy_url
                          + '","auth": "false"}}'
                      )
                      cmd = f'/usr/bin/az connectedmachine extension create --no-wait --name "AzureMonitorLinuxAgent" --publisher "Microsoft.Azure.Monitor" --type "AzureMonitorLinuxAgent" --machine-name "{hostname}" --resource-group "{resource_group}" --location "{location}" --verbose --settings \'{settings}\''
                  else:
                      cmd = f'/usr/bin/az connectedmachine extension create --no-wait --name "AzureMonitorLinuxAgent" --publisher "Microsoft.Azure.Monitor" --type "AzureMonitorLinuxAgent" --machine-name "{hostname}" --resource-group "{resource_group}" --location "{location}" --verbose'

                  version = ama_config.get("VERSION")
                  if version is not None:
                      cmd += f' --type-handler-version "{version}"'

                  logger.info("Installing Azure Monitor agent...")
                  telemetry_common.az_login(logger, ama_config)

                  try:
                      telemetry_common.run_cmd(logger, cmd)
                  except:
                      logger.info("Trying to install Azure Monitor agent...")
                  finally:
                      telemetry_common.az_logout(logger)


              def run_uninstall(logger, ama_config):
                  logger.info("Uninstall Azure Monitor agent...")
                  resource_group = ama_config.get("RESOURCE_GROUP")
                  hostname = socket.gethostname()
                  cmd = f'/usr/bin/az connectedmachine extension delete --name "AzureMonitorLinuxAgent" --machine-name "{hostname}" --resource-group "{resource_group}" --yes --verbose'

                  telemetry_common.az_login(logger, ama_config)
                  logger.info("Uninstalling Azure Monitor agent...")

                  try:
                      telemetry_common.run_cmd(logger, cmd)
                  except:
                      print("Trying to uninstall Azure Monitor agent...")
                  finally:
                      telemetry_common.az_logout(logger)


              def ama_installation(logger, ama_config):
                  logger.info("Executing AMA extenstion installation...")
                  telemetry_common.az_cli_cm_ext_install(logger, ama_config)

                  # Get connected machine properties
                  cm_provisioning_state, cm_status = telemetry_common.get_cm_properties(
                    logger, ama_config
                  )

                  if (
                    cm_provisioning_state == telemetry_common.AgentryResult.SUCCEEDED
                    and cm_status == telemetry_common.AgentryResult.CONNECTED
                  ):
                    # Get AzureMonitorLinuxAgent extension status
                    ext_provisioning_state = telemetry_common.get_cm_extension_state(
                      logger, ama_config, "AzureMonitorLinuxAgent"
                    )
  
                    if ext_provisioning_state == telemetry_common.AgentryResult.SUCCEEDED:
                      logger.info(telemetry_common.OnboardingMessage.COMPLETED)
                      return True
                    elif ext_provisioning_state == telemetry_common.AgentryResult.FAILED:
                      run_uninstall(logger, ama_config)
                      logger.warning(telemetry_common.OnboardingMessage.STILL_TRYING)
                      return False
                    elif ext_provisioning_state == telemetry_common.AgentryResult.CREATING:
                      logger.warning(telemetry_common.OnboardingMessage.STILL_CREATING)
                      return False
                    else:
                      run_install(logger, ama_config)
                      logger.warning(telemetry_common.OnboardingMessage.STILL_TRYING)
                      return False
                  else:
                    logger.error("Server not arc enrolled, enroll the server and retry")
                    return False


              def main():
                  timeout = 60  # TODO: increase when executed via systemd unit
                  start_time = time.time()
                  end_time = start_time + timeout

                  config_file = telemetry_common.arc_config_file

                  logger = telemetry_common.get_logger(__name__)

                  logger.info("Running setup_azure_monitor_agent.py...")

                  if config_file is None:
                      raise Exception("config file is expected")

                  ama_config = {}

                  with open(config_file, "r") as file:
                      ama_config = json.load(file)

                  ama_installed = False

                  while time.time() < end_time:
                      logger.info("Installing AMA extension...")
                      try:
                          ama_installed = ama_installation(logger, ama_config)
                      except Exception as e:
                          logger.error(f"Could not install AMA extension: {e}")
                      if ama_installed:
                          break
                      logger.info("Sleeping 30s...")  # retry for Azure info
                      time.sleep(30)


              if __name__ == "__main__":
                  main()

              EOF


              nsenter -t1 -m -u -n -i tee "\${WORKDIR}"/arc-connect.sh > /dev/null <<EOF
              #!/bin/bash
              set -e

              echo "{\"VERSION\": \"\${VERSION}\", \"SUBSCRIPTION_ID\": \"\${SUBSCRIPTION_ID}\", \"SERVICE_PRINCIPAL_ID\": \"\${SERVICE_PRINCIPAL_ID}\", \"SERVICE_PRINCIPAL_SECRET\": \"\${SERVICE_PRINCIPAL_SECRET}\", \"RESOURCE_GROUP\": \"\${RESOURCE_GROUP}\", \"TENANT_ID\": \"\${TENANT_ID}\", \"LOCATION\": \"\${LOCATION}\", \"PROXY_URL\": \"\${PROXY_URL}\", \"CONNECTEDMACHINE_AZCLI_VERSION\": \"\${CONNECTEDMACHINE_AZCLI_VERSION}\"}" > "\${WORKDIR}"/telemetry/arc-connect.json

              if [ "\${INSTALL_AZURE_MONITOR_AGENT}" = "true" ]; then
                echo "Installing Azure Monitor agent..."
                /usr/bin/python3 "\${WORKDIR}"/telemetry/setup_azure_monitor_agent.py > "\${WORKDIR}"/setup_azure_monitor_agent.out
                cat "\${WORKDIR}"/setup_azure_monitor_agent.out
                if grep "Could not install AMA extension" "\${WORKDIR}"/setup_azure_monitor_agent.out > /dev/null; then
                  exit 1
                fi
              fi
              EOF

              nsenter -t1 -m -u -n -i sh "\${WORKDIR}"/arc-connect.sh
              nsenter -t1 -m -u -n -i rm -rf "\${WORKDIR}"
              echo "Server monitoring configured successfully"
              tail -f /dev/null
          livenessProbe:
            initialDelaySeconds: 600
            periodSeconds: 60
            timeoutSeconds: 30
            exec:
              command:
                - /bin/bash
                - -c
                - |
                  set -e
                  WORKDIR=\$(nsenter -t1 -m -u -n -i mktemp -d)
                  trap 'nsenter -t1 -m -u -n -i rm -rf "\${WORKDIR}"' ERR EXIT
                  nsenter -t1 -m -u -n -i tee "\${WORKDIR}"/liveness.sh > /dev/null <<EOF
                  #!/bin/bash
                  set -e

                  # Check AMA processes
                  ps -ef | grep "\\\s/opt/microsoft/azuremonitoragent/bin/agentlauncher\\\s"
                  ps -ef | grep "\\\s/opt/microsoft/azuremonitoragent/bin/mdsd\\\s"
                  ps -ef | grep "\\\s/opt/microsoft/azuremonitoragent/bin/amacoreagent\\\s"

                  # Check Arc server agent is Connected
                  AGENTSTATUS="\\\$(azcmagent show -j)"
                  if [[ \\\$(echo "\\\${AGENTSTATUS}" | jq -r .status) != "Connected" ]]; then
                    echo "azcmagent is not connected"
                    echo "\\\${AGENTSTATUS}"
                    exit 1
                  fi

                  # Verify dependent services are running
                  while IFS= read -r status; do
                    if [[ "\\\${status}" != "active" ]]; then
                      echo "one or more azcmagent services not active"
                      echo "\\\${AGENTSTATUS}"
                      exit 1
                    fi
                  done < <(jq -r '.services[] | (.status)' <<<\\\${AGENTSTATUS})

                  # Run connectivity tests
                  RESULT="\\\$(azcmagent check -j)"
                  while IFS= read -r reachable; do
                    if [[ ! \\\${reachable} ]]; then
                      echo "one or more connectivity tests failed"
                      echo "\\\${RESULT}"
                      exit 1
                    fi
                  done < <(jq -r '.[] | (.reachable)' <<<\\\${RESULT})

                  EOF

                  nsenter -t1 -m -u -n -i sh "\${WORKDIR}"/liveness.sh
                  nsenter -t1 -m -u -n -i rm -rf "\${WORKDIR}"
                  echo "Liveness check succeeded"

      tolerations:
        - operator: "Exists"
          effect: "NoSchedule"

EOF
}

SUBSCRIPTION_ID="${SUBSCRIPTION_ID:?SUBSCRIPTION_ID must be set}"
SERVICE_PRINCIPAL_ID="${SERVICE_PRINCIPAL_ID:?SERVICE_PRINCIPAL_ID must be set}"
SERVICE_PRINCIPAL_SECRET="${SERVICE_PRINCIPAL_SECRET:?SERVICE_PRINCIPAL_SECRET must be set}"
RESOURCE_GROUP="${RESOURCE_GROUP:?RESOURCE_GROUP must be set}"
TENANT_ID="${TENANT_ID:?TENANT_ID must be set}"
LOCATION="${LOCATION:?LOCATION must be set}"
PROXY_URL="${PROXY_URL:?PROXY_URL must be set}"
INSTALL_AZURE_MONITOR_AGENT="${INSTALL_AZURE_MONITOR_AGENT:?INSTALL_AZURE_MONITOR_AGENT must be true/false}"
NAMESPACE="${NAMESPACE:?NAMESPACE must be set}"
AZURE_MONITOR_AGENT_VERSION="${AZURE_MONITOR_AGENT_VERSION:-"1.24.2"}"
CONNECTEDMACHINE_AZCLI_VERSION="${CONNECTEDMACHINE_AZCLI_VERSION:-"0.6.0"}"

create_secret
create_daemonset

Vereisten-VM

• Clusterbeheerder toegang tot het Nexus Kubernetes-cluster.

• Als u servers met Azure Arc wilt gebruiken, registreert u de volgende Azure-resourceproviders in uw abonnement:

  • Microsoft.HybridCompute
  • Microsoft.GuestConfiguration
  • Microsoft.HybridConnectivity

Registreer deze resourceproviders als u dit nog niet hebt gedaan:

az account set --subscription "{the Subscription Name}"
az provider register --namespace 'Microsoft.HybridCompute'
az provider register --namespace 'Microsoft.GuestConfiguration'
az provider register --namespace 'Microsoft.HybridConnectivity'

• Wijs indien nodig een Azure-service-principal toe aan de volgende ingebouwde Azure-rollen. Wijs de service-principal toe aan de Azure-resourcegroep waaraan de machines moeten worden gekoppeld:

Rol	Nodig om
Azure Verbinding maken ed Machine Resource Beheer istrator of Inzender	Verbinding maken Met Arc ingeschakelde Nexus Kubernetes-cluster-VM-server in de resourcegroep en installeer de Azure Monitoring Agent (AMA)
Inzender of inzender bewaken	Een REGEL voor gegevensverzameling (DCR) maken in de resourcegroep en servers met Arc eraan koppelen
Gebruikerstoegang Beheer istrator en Inzender voor resourcebeleid of -inzender	Nodig als u Azure Policy-toewijzingen wilt gebruiken om ervoor te zorgen dat een DCR is gekoppeld aan machines met Arc
Inzender voor Kubernetes-extensies	Nodig om de K8s-extensie voor Container Insights te implementeren

Omgeving instellen

Kopieer en voer de opgenomen scripts uit. U kunt ze uitvoeren vanuit een Azure Cloud Shell in Azure Portal. U kunt ze ook uitvoeren vanaf een Linux-opdrachtprompt waar het Kubernetes-opdrachtregelprogramma (kubectl) en Azure CLI zijn geïnstalleerd.

Voordat u de opgenomen scripts uitvoert, definieert u de volgende omgevingsvariabelen:

Omgevingsvariabele	Beschrijving
SUBSCRIPTION_ID	De id van het Azure-abonnement dat de resourcegroep bevat
RESOURCE_GROUP	De naam van de resourcegroep waarin de server met Arc en de bijbehorende resources worden gemaakt
LOCATIE	De Azure-regio waar de servers met Arc en de bijbehorende resources worden gemaakt
SERVICE_PRINCIPAL_ID	De appId van de Azure-service-principal met de juiste roltoewijzing(en)
SERVICE_PRINCIPAL_SECRET	Het verificatiewachtwoord voor de Azure-service-principal
TENANT_ID	De id van de tenantmap waarin de service-principal bestaat
PROXY_URL	De proxy-URL die moet worden gebruikt voor het maken van verbinding met Azure-services
NAAMRUIMTE	De naamruimte waarin de Kubernetes-artefacten worden gemaakt

Voor het gemak kunt u het sjabloonbestand arc-connect.envwijzigen om de waarden van de omgevingsvariabele in te stellen.

# Apply the modified values to the environment
 ./arc-connect.env

Een regel voor gegevensverzameling toevoegen (DCR)

Koppel de servers met Arc aan een DCR om het verzamelen van logboekgegevens in een Log Analytics-werkruimte in te schakelen. U kunt de DCR maken via Azure Portal of CLI. Hier vindt u informatie over het maken van een DCR voor het verzamelen van gegevens van de VM's.

Met het opgenomen dcr.sh script maakt u een DCR in de opgegeven resourcegroep waarmee logboekverzameling wordt geconfigureerd.

1. Zorg voor de juiste omgevingsinstellingen en rolvereisten voor de service-principal. De DCR wordt gemaakt in de opgegeven resourcegroep.

2. Maak of identificeer een Log Analytics-werkruimte voor logboekgegevensopname volgens de DCR. Stel een omgevingsvariabele in LAW_RESOURCE_ID op de resource-id. Haal de resource-id op voor de naam van een bekende Log Analytics-werkruimte:

export LAW_RESOURCE_ID=$(az monitor log-analytics workspace show -g "${RESOURCE_GROUP}" -n <law name> --query id -o tsv)

3. Voer het dcr.sh-script uit. Er wordt een DCR gemaakt in de opgegeven resourcegroep met de naam ${RESOURCE_GROUP}-syslog-dcr

./dcr.sh

Bekijk of beheer de DCR vanuit Azure Portal of CLI. Standaard is het Niveau van het Linux Syslog-logboek ingesteld op INFO. U kunt het logboekniveau zo nodig wijzigen.

Notitie

Koppel handmatig of via een beleid servers die zijn gemaakt vóór het maken van de DCR. Zie hersteltaak.

Serverbronnen met Arc koppelen aan DCR

Koppel de serverbronnen met Arc aan de gemaakte DCR voor logboeken om naar de Log Analytics-werkruimte te stromen. Er zijn opties voor het koppelen van servers aan DCR's.

Azure Portal of CLI gebruiken om geselecteerde servers met Arc te koppelen aan DCR

Voeg in Azure Portal serverresource met Arc toe aan de DCR met behulp van de sectie Resources.

Gebruik deze koppeling voor informatie over het koppelen van de resources via de Azure CLI.

Azure Policy gebruiken om DCR-koppelingen te beheren

Wijs een beleid toe aan de resourcegroep om de koppeling af te dwingen. Er is een ingebouwde beleidsdefinitie om Linux Arc-machines te koppelen aan een DCR. Wijs het beleid toe aan de resourcegroep met DCR als parameter. Het zorgt ervoor dat alle servers met Arc, binnen de resourcegroep, met dezelfde DCR worden gekoppeld.

Selecteer in Azure Portal de Assign knop op de pagina beleidsdefinitie .

Voor het gemak wijst het opgegeven assign.sh script het ingebouwde beleid toe aan de opgegeven resourcegroep en DCR die met het dcr.sh script is gemaakt.

1. Zorg ervoor dat de juiste omgevingsinstellingen en rolvereisten zijn ingesteld voor de service-principal om beleid en roltoewijzingen uit te voeren.
2. Maak de DCR in de resourcegroep met behulp van een dcr.sh script zoals beschreven in de sectie Een regel voor gegevensverzameling toevoegen.
3. Voer het assign.sh-script uit. Hiermee worden de beleidstoewijzing en de benodigde roltoewijzingen gemaakt.

./assign.sh

Azure-bewakingsagent installeren

Gebruik de opgenomen install.sh gegevens waarmee een Kubernetes-daemonSet wordt gemaakt op het Nexus Kubernetes-cluster. Er wordt een pod geïmplementeerd op elk clusterknooppunt en de Azure Monitoring Agent (AMA) geïnstalleerd. De daemonSet bevat ook een livenesstest die de serververbinding en AMA-processen bewaakt.

Notitie

Als u Azure Monitoring Agent wilt installeren, moet u eerst arc verbinden met de Nexus Kubernetes-cluster-VM's. Dit proces wordt geautomatiseerd als u de nieuwste versiebundel gebruikt. Als de versiebundel die u gebruikt echter geen ondersteuning biedt voor cluster-VM Arc-inschrijving, moet u uw cluster upgraden naar de nieuwste versiebundel. Raadpleeg de door Nexus Kubernetes-cluster ondersteunde versies voor meer informatie over de versiebundel

1. Stel de omgeving in zoals opgegeven in de omgevingsinstellingen. Stel de huidige kubeconfig context in voor de Nexus Kubernetes-cluster-VM's.
2. Toegang tot het Nexus Kubernetes-cluster toestaan Kubectl .

   Notitie

   Wanneer u een Nexus Kubernetes-cluster maakt, maakt Nexus automatisch een beheerde resourcegroep die is toegewezen aan het opslaan van de clusterresources, binnen deze groep, wordt de met Arc verbonden clusterresource tot stand gebracht.

   Voor toegang tot uw cluster moet u de clusterverbinding kubeconfiginstellen. Nadat u zich hebt aangemeld bij Azure CLI met de relevante Microsoft Entra-entiteit, kunt u de kubeconfig benodigde gegevens verkrijgen om te communiceren met het cluster vanaf elke locatie, zelfs buiten de firewall eromheen.

   1. Stel CLUSTER_NAMEen RESOURCE_GROUPSUBSCRIPTION_ID variabelen in.

      CLUSTER_NAME="myNexusK8sCluster"
      RESOURCE_GROUP="myResourceGroup"
      SUBSCRIPTION_ID=<set the correct subscription_id>
      

   2. Query's uitvoeren op beheerde resourcegroep met az en opslaan in MANAGED_RESOURCE_GROUP

       az account set -s $SUBSCRIPTION_ID
       MANAGED_RESOURCE_GROUP=$(az networkcloud kubernetescluster show -n $CLUSTER_NAME -g $RESOURCE_GROUP --output tsv --query managedResourceGroupConfiguration.name)
      

   3. Met de volgende opdracht wordt een connectedk8s-proxy gestart waarmee u verbinding kunt maken met de Kubernetes-API-server voor het opgegeven Nexus Kubernetes-cluster.

      az connectedk8s proxy -n $CLUSTER_NAME  -g $MANAGED_RESOURCE_GROUP &
      

   4. Gebruik kubectl dit om aanvragen naar het cluster te verzenden:

      kubectl get pods -A
      

      U ziet nu een antwoord van het cluster met de lijst met alle knooppunten.

   Notitie

   Als u het foutbericht 'Kan geen toegangstoken posten naar clientproxyFailed om verbinding te maken met MSI' wordt weergegeven, moet u mogelijk een az login nieuwe verificatie uitvoeren bij Azure.

3. Voer het install.sh script uit vanaf de opdrachtprompt met kubectl-toegang tot het Nexus Kubernetes-cluster.

Het script implementeert het daemonSet in het cluster. Controleer de voortgang als volgt:

# Run the install script and observe results
./install.sh
kubectl get pod --selector='name=naks-vm-telemetry'
kubectl logs <podname>

Na voltooiing registreert het systeem het bericht 'Serverbewaking geconfigureerd'.

Notitie

Koppel deze verbonden servers aan de DCR. Nadat u een beleid hebt geconfigureerd, kan er enige vertraging optreden om de logboeken in de Azure Log Analytics-werkruimte te bekijken

Nexus Kubernetes-cluster bewaken - K8s-laag

Vereisten-Kubernetes

Er zijn bepaalde vereisten die de operator moet garanderen om de bewakingshulpprogramma's op Nexus Kubernetes-clusters te configureren.

Container Insights slaat de gegevens op in een Log Analytics-werkruimte. Logboekgegevens stromen naar de werkruimte waarvan u de resource-id hebt opgegeven tijdens de eerste scripts die worden behandeld in de sectie 'Een regel voor gegevensverzameling (DCR) toevoegen' . Anders worden gegevenstrechters weergegeven in een standaardwerkruimte in de resourcegroep die is gekoppeld aan uw abonnement (op basis van de Azure-locatie).

Een voorbeeld voor VS - oost kan er als volgt uitzien:

• Naam van Log Analytics-werkruimte: DefaultWorkspace-GUID-EUS<>
• Resourcegroepnaam: DefaultResourceGroup-EUS

Voer de volgende opdracht uit om een resource-id voor een bestaande Log Analytics-werkruimte op te halen:

az login

az account set --subscription "<Subscription Name or ID the Log Analytics workspace is in>"

az monitor log-analytics workspace show --workspace-name "<Log Analytics workspace Name>" \
  --resource-group "<Log Analytics workspace Resource Group>" \
  -o tsv --query id

Voor het implementeren van Container Insights en het weergeven van gegevens in de toepasselijke Log Analytics-werkruimte zijn bepaalde roltoewijzingen in uw account vereist. Bijvoorbeeld de roltoewijzing Inzender. Zie de instructies voor het toewijzen van vereiste rollen:

• Rol Log Analytics-inzender : vereiste machtigingen voor het inschakelen van containerbewaking op een CNF-cluster (ingericht).
• Log Analytics Reader-rol : niet-leden van de rol Log Analytics-inzender ontvangen machtigingen om gegevens weer te geven in de Log Analytics-werkruimte zodra u containerbewaking inschakelt.

De clusterextensie installeren

Meld u aan bij Azure Cloud Shell voor toegang tot het cluster:

az login

az account set --subscription "<Subscription Name or ID the Provisioned Cluster is in>"

Implementeer nu de Container Insights-extensie op een ingericht Nexus Kubernetes-cluster met behulp van een van de volgende twee opdrachten:

Met vooraf gemaakte Log Analytics-werkruimte van de klant

az k8s-extension create --name azuremonitor-containers \
  --cluster-name "<Nexus Kubernetes cluster Name>" \
  --resource-group "<Nexus Kubernetes cluster Resource Group>" \
  --cluster-type connectedClusters \
  --extension-type Microsoft.AzureMonitor.Containers \
  --release-train preview \
  --configuration-settings logAnalyticsWorkspaceResourceID="<Log Analytics workspace Resource ID>" \
  amalogsagent.useAADAuth=true

De standaard Log Analytics-werkruimte gebruiken

az k8s-extension create --name azuremonitor-containers \
  --cluster-name "<Nexus Kubernetes cluster Name>" \
  --resource-group "<Nexus Kubernetes cluster Resource Group>" \
  --cluster-type connectedClusters \
  --extension-type Microsoft.AzureMonitor.Containers \
  --release-train preview \
  --configuration-settings amalogsagent.useAADAuth=true

Clusterextensie valideren

Valideer de geslaagde implementatie van de activering van bewakingsagents op Nexus Kubernetes-clusters met behulp van de volgende opdracht:

az k8s-extension show --name azuremonitor-containers \
  --cluster-name "<Nexus Kubernetes cluster Name>" \
  --resource-group "<Nexus Kubernetes cluster Resource Group>" \
  --cluster-type connectedClusters

Zoek naar de inrichtingsstatus Geslaagd voor de extensie. De opdracht 'k8s-extension create' heeft mogelijk ook de status geretourneerd.

Logboeken en verzameling metrische gegevens aanpassen

Container Insights biedt eindgebruikers functionaliteit om de verzameling logboeken en metrische gegevens van Nexus Kubernetes-clusters af te stemmen. Configureer containerinzichtagentgegevensverzameling.

Extra resources

• Raadpleeg de documentatie voor werkmappen en vervolgens kunt u Operator Nexus-telemetrievoorbeeldoperator Nexus-werkmappen gebruiken.
• Bekijk Azure Monitor-waarschuwingen, hoe u Azure Monitor-waarschuwingsregels maakt en voorbeeldsjablonen voor Operator Nexus-waarschuwingen gebruikt.