Nexus Kubernetes-fürt monitorozása

Minden Nexus Kubernetes-fürt több rétegből áll:

• Virtual Machines (VMs)
• Kubernetes-réteg
• Alkalmazás podok

Ábra: Minta Nexus Kubernetes-fürt

Egy példányban a Nexus Kubernetes-fürtök opcionális Tároló Elemzések megfigyelhetőségi megoldással vannak kézbesítve. A tároló Elemzések rögzíti a Nexus Kubernetes-fürtök és számítási feladatok naplóit és metrikáit. Kizárólag ön dönti el, hogy engedélyezi-e ezt az eszközt, vagy üzembe helyezi-e a saját telemetriai vermet.

A Nexus Kubernetes-fürt az Azure monitorozási eszközével a következőképpen néz ki:

Ábra: Nexus Kubernetes-fürt monitorozási eszközökkel

Bővítmény előkészítése a parancssori felülettel felügyelt identitás hitelesítésével

Dokumentáció az Azure CLI-vel való kezdéshez, a több operációs rendszerre való telepítéshez és a PARANCSSOR-bővítmények telepítéséhez.

Telepítse a szükséges CLI-bővítmények legújabb verzióját.

Nexus Kubernetes-fürt monitorozása – virtuálisgép-réteg

Ez az útmutató lépéseket és segédprogramszkripteket biztosít a Nexus Kubernetes-fürt virtuális gépeinek Azure-hoz való csatlakoztatásához, és lehetővé teszi a figyelési ügynökök számára a rendszernaplók gyűjtését ezekből a virtuális gépekről az Azure Monitoring Agent használatával. Az utasítások további részleteket rögzítenek arról, hogyan állíthat be naplóadat-gyűjtést a Log Analytics-munkaterületre.

A következő erőforrások biztosítják a támogatást:

• arc-connect.env: használja ezt a sablonfájlt a belefoglalt szkriptek által igényelt környezeti változók létrehozásához

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: ezzel a szkripttel hozzon létre egy adatgyűjtési szabályt (DCR) a syslog-gyűjtemény konfigurálásához

#!/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: a szkript használatával hozzon létre egy szabályzatot, amely társítja a DCR-t egy erőforráscsoport összes Arc-kompatibilis kiszolgálójával

#!/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: Telepítse az Azure Monitoring Agentet minden egyes virtuális gépre, hogy monitorozási adatokat gyűjtsön az Azure-beli virtuális gépekről.

#!/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

Előfeltételek –virtuális gép

• Fürtadminisztrátori hozzáférés a Nexus Kubernetes-fürthöz.

• Az Azure Arc-kompatibilis kiszolgálók használatához regisztrálja a következő Azure-erőforrás-szolgáltatókat az előfizetésében:

  • Microsoft.HybridCompute
  • Microsoft.GuestConfiguration
  • Microsoft.Hybrid Csatlakozás ivity

Ha korábban még nem tette meg, regisztrálja ezeket az erőforrás-szolgáltatókat:

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'

• Szükség szerint rendeljen hozzá egy Azure-szolgáltatásnevet a következő beépített Azure-szerepkörökhöz. Rendelje hozzá a szolgáltatásnevet a csatlakoztatni kívánt gépeket tartalmazó Azure-erőforráscsoporthoz:

Szerepkör	Szükséges
Azure Csatlakozás ed Machine Resource Rendszergazda istrator vagy Közreműködő	Csatlakozás Arc-kompatibilis Nexus Kubernetes-fürt virtuálisgép-kiszolgálóját az erőforráscsoportban, és telepítse az Azure Monitoring Agentet (AMA)
Közreműködő vagy közreműködő figyelése	Adatgyűjtési szabály (DCR) létrehozása az erőforráscsoportban, és Arc-kompatibilis kiszolgálók társítása hozzá
Felhasználói hozzáférés Rendszergazda istrator és erőforrásházirend-közreműködő vagy -közreműködő	Ha Azure-szabályzat-hozzárendelés(ek) használatával szeretné biztosítani, hogy a DCR az Arc-kompatibilis gépekhez legyen társítva
Kubernetes-bővítmény közreműködője	A Container Elemzések K8s bővítményének üzembe helyezéséhez szükséges

Környezet beállítása

Másolja és futtassa a mellékelt szkripteket. Futtathatja őket egy Azure Cloud Shellből az Azure Portalon. Futtathatja őket linuxos parancssorból is, ahol telepítve van a Kubernetes parancssori eszköze (kubectl) és az Azure CLI.

A mellékelt szkriptek futtatása előtt adja meg a következő környezeti változókat:

Környezeti változó	Leírás
SUBSCRIPTION_ID	Az erőforráscsoportot tartalmazó Azure-előfizetés azonosítója
RESOURCE_GROUP	Az erőforráscsoport neve, ahol az Arc-kompatibilis kiszolgáló és a társított erőforrások létrejönnek
HELY	Az Azure-régió, ahol az Arc-kompatibilis kiszolgálók és a társított erőforrások létrejönnek
Standard kiadás RVICE_PRINCIPAL_ID	Az Azure-szolgáltatásnév appId azonosítója a megfelelő szerepkör-hozzárendeléssel(ek)
Standard kiadás RVICE_PRINCIPAL_Standard kiadás CRET	Az Azure-szolgáltatásnév hitelesítési jelszava
TENANT_ID	Annak a bérlői címtárnak az azonosítója, ahol a szolgáltatásnév létezik
PROXY_URL	Az Azure-szolgáltatásokhoz való csatlakozáshoz használandó proxy URL-cím
NÉVTÉR	Az a névtér, ahol a Kubernetes-összetevők létrejönnek

Az egyszerűség kedvéért módosíthatja a sablonfájlt a arc-connect.envkörnyezeti változó értékeinek beállításához.

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

Adatgyűjtési szabály (DCR) hozzáadása

Társítsa az Arc-kompatibilis kiszolgálókat egy DCR-hez a naplóadatok Log Analytics-munkaterületre való gyűjtésének engedélyezéséhez. A DCR-t az Azure Portalon vagy a parancssori felületen hozhatja létre. A virtuális gépekről adatokat gyűjtő DCR létrehozásával kapcsolatos információk itt érhetők el.

A belefoglalt dcr.sh szkript létrehoz egy DCR-t a megadott erőforráscsoportban, amely konfigurálja a naplógyűjteményt.

1. A szolgáltatásnév megfelelő környezetbeállításának és szerepkör-előfeltételeinek biztosítása. A DCR a megadott erőforráscsoportban jön létre.

2. Hozzon létre vagy azonosítsa a Log Analytics-munkaterületet a naplóadatok betöltéséhez a DCR-nek megfelelően. Állítson be egy környezeti változót, LAW_RESOURCE_ID az erőforrás-azonosítójára. Kérje le egy ismert Log Analytics-munkaterület nevének erőforrás-azonosítóját:

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

3. Futtassa a dcr.sh szkriptet. Létrehoz egy DCR-t a megadott erőforráscsoportban ${RESOURCE_GROUP}-syslog-dcr néven

./dcr.sh

A DCR megtekintése/kezelése az Azure Portalról vagy a parancssori felületről. Alapértelmezés szerint a Linux Syslog naplószintje "INFO" értékre van állítva. Szükség szerint módosíthatja a naplószintet.

Feljegyzés

Manuálisan vagy szabályzaton keresztül társíthatja a DCR létrehozása előtt létrehozott kiszolgálókat. Lásd: szervizelési feladat.

Arc-kompatibilis kiszolgálói erőforrások társítása a DCR-hez

Társítsa az Arc-kompatibilis kiszolgálóerőforrásokat a létrehozott DCR-hez, hogy a naplók a Log Analytics-munkaterületre áramolhassanak. A kiszolgálók tartományvezérlőkkel való társítására is van lehetőség.

A kijelölt Arc-kompatibilis kiszolgálók A DCR-hez való társítása az Azure Portal vagy a parancssori felület használatával

Az Azure Portalon adja hozzá az Arc-kompatibilis kiszolgálói erőforrást a DCR-hez az Erőforrások szakasz használatával.

Ezen a hivatkozáson tájékozódhat az erőforrások Azure CLI-vel való társításáról.

DCR-társítások kezelése az Azure Policy használatával

Rendeljen hozzá egy szabályzatot az erőforráscsoporthoz a társítás kényszerítéséhez. Létezik egy beépített szabályzatdefiníció, amellyel Linux Arc-gépeket társíthat egy DCR-hez. Rendelje hozzá a szabályzatot az erőforráscsoporthoz a DCR paraméterrel. Biztosítja az összes Arc-kompatibilis kiszolgáló társítását az erőforráscsoporton belül ugyanazzal a DCR-vel.

Az Azure Portalon válassza ki a Assign gombot a szabályzatdefiníció oldalán.

Az egyszerűség kedvéért a megadott assign.sh szkript hozzárendeli a beépített szabályzatot a megadott erőforráscsoporthoz és a dcr.sh szkripttel létrehozott DCR-hez.

1. Gondoskodjon arról, hogy a szolgáltatásnév megfelelő környezetbeállítást és szerepkör-előfeltételeket biztosítson a szabályzatok és szerepkör-hozzárendelések elvégzéséhez.
2. Hozza létre a DCR-t az erőforráscsoportban az Adatgyűjtési szabály hozzáadása szakaszban ismertetett szkript használatávaldcr.sh.
3. Futtassa az assign.sh szkriptet. Létrehozza a szabályzat-hozzárendelést és a szükséges szerepkör-hozzárendeléseket.

./assign.sh

Az Azure Monitoring Agent telepítése

Használja azt a részt install.sh , amely létrehoz egy Kubernetes-démonkészletet a Nexus Kubernetes-fürtön. Minden fürtcsomóponton üzembe helyez egy podot, és telepíti az Azure Monitoring Agentet (AMA). Emellett daemonSet tartalmaz egy élőségi mintavételt is, amely figyeli a kiszolgálókapcsolatot és az AMA-folyamatokat.

Feljegyzés

Az Azure Monitoring Agent telepítéséhez először az Arcnak kell csatlakoztatnia a Nexus Kubernetes-fürt virtuális gépeit. Ez a folyamat automatikusan történik, ha a legújabb verziócsomagot használja. Ha azonban a használt verziócsomag alapértelmezés szerint nem támogatja a fürt virtuálisgép-arc-regisztrációját, frissítenie kell a fürtöt a legújabb verziócsomagra. A verziócsomaggal kapcsolatos további információkért tekintse meg a Nexus Kubernetes-fürt támogatott verzióit

1. Állítsa be a környezetet a környezet beállításában megadott módon. Adja meg a Nexus Kubernetes-fürt virtuális gépeinek aktuális kubeconfig környezetét.
2. Hozzáférés engedélyezése Kubectl a Nexus Kubernetes-fürthöz.

   Feljegyzés

   A Nexus Kubernetes-fürt létrehozásakor a Nexus automatikusan létrehoz egy felügyelt erőforráscsoportot, amely a fürt erőforrásainak tárolására van kijelölve. Ebben a csoportban létrejön az Archoz csatlakoztatott fürterőforrás.

   A fürt eléréséhez be kell állítania a fürtcsatlakozás kubeconfigbeállítását. Miután bejelentkezett az Azure CLI-be a megfelelő Microsoft Entra entitással, bárhonnan beszerezheti a kubeconfig fürttel való kommunikációhoz szükséges adatokat, még az azt körülvevő tűzfalon kívül is.

   1. Beállítás CLUSTER_NAMEés RESOURCE_GROUPSUBSCRIPTION_ID változók.

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

   2. Felügyelt erőforráscsoport lekérdezése és az tárolása 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. Az alábbi parancs elindít egy connectedk8s proxyt, amely lehetővé teszi a megadott Nexus Kubernetes-fürt Kubernetes API-kiszolgálóhoz való csatlakozását.

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

   4. Kérések kubectl küldése a fürtnek:

      kubectl get pods -A
      

      Ekkor megjelenik a fürt válasza, amely tartalmazza az összes csomópont listáját.

   Feljegyzés

   Ha a következő hibaüzenet jelenik meg: "Nem sikerült közzétenni a hozzáférési jogkivonatot az ügyfélproxyhozAz MSI-hez való csatlakozáshoz nem sikerült közzétenni", előfordulhat, hogy újra kell hitelesítenie az login magát az Azure-ral.

3. Futtassa a install.sh szkriptet a parancssorból kubectl-hozzáféréssel a Nexus Kubernetes-fürthöz.

A szkript üzembe helyezi a daemonSet fürtön. Figyelje az előrehaladást az alábbiak szerint:

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

A befejezés után a rendszer naplózza a "Kiszolgálófigyelés sikeresen konfigurálva" üzenetet.

Feljegyzés

Társítsa ezeket a csatlakoztatott kiszolgálókat a DCR-hez. Miután konfigurált egy szabályzatot, előfordulhat, hogy némi késéssel figyeli a naplókat az Azure Log Analytics-munkaterületen

Nexus Kubernetes-fürt monitorozása – K8s-réteg

Előfeltételek–Kubernetes

Vannak bizonyos előfeltételek, amelyeket az üzemeltetőnek biztosítania kell a Nexus Kubernetes-fürtök monitorozási eszközeinek konfigurálásához.

A tároló Elemzések egy Log Analytics-munkaterületen tárolja az adatait. Naplózza az adatokat abba a munkaterületre, amelynek erőforrás-azonosítóját az "Adatgyűjtési szabály (DCR) hozzáadása" szakaszban ismertetett kezdeti szkriptek során adta meg. Máskülönben az adattölcsérek egy alapértelmezett munkaterületre kerülnek az előfizetéséhez társított erőforráscsoportban (az Azure-hely alapján).

Az USA keleti régióira a következőhöz hasonló példa jelenhet meg:

• Log Analytics-munkaterület neve: DefaultWorkspace-GUID-EUS<>
• Erőforráscsoport neve: DefaultResourceGroup-EUS

Futtassa a következő parancsot egy már meglévő Log Analytics-munkaterület erőforrás-azonosítójának lekéréséhez:

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

A Tároló Elemzések üzembe helyezéséhez és az adatok megtekintéséhez a megfelelő Log Analytics-munkaterületen bizonyos szerepkör-hozzárendelések szükségesek a fiókjában. Például a "Közreműködő" szerepkör-hozzárendelés. Tekintse meg a szükséges szerepkörök hozzárendelésére vonatkozó utasításokat:

• Log Analytics-közreműködői szerepkör: szükséges engedélyek a tárolófigyelés engedélyezéséhez egy CNF-fürtön (kiépített) fürtön.
• Log Analytics-olvasó szerepkör: a Log Analytics-közreműködői szerepkör nem tagjai, a tárolófigyelés engedélyezése után engedélyt kapnak az adatok megtekintésére a Log Analytics-munkaterületen.

A fürtbővítmény telepítése

Jelentkezzen be az Azure Cloud Shellbe a fürt eléréséhez:

az login

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

Most helyezze üzembe a Container Elemzések bővítményt egy kiépített Nexus Kubernetes-fürtön a következő két parancs valamelyikével:

Az ügyfél által előre létrehozott Log Analytics-munkaterülettel

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

Az alapértelmezett Log Analytics-munkaterület használata

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

Fürtbővítmény ellenőrzése

Ellenőrizze a monitorozási ügynökök engedélyezésének sikeres üzembe helyezését a Nexus Kubernetes-fürtökön az alábbi paranccsal:

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

Keresse meg a bővítmény "Sikeres" kiépítési állapotát. Előfordulhat, hogy a "k8s-extension create" parancs is visszaadta az állapotot.

Naplók és metrikák gyűjteményének testreszabása

A Tároló Elemzések a végfelhasználók számára lehetővé teszi a naplók és metrikák gyűjteményének finomhangolását a Nexus Kubernetes-fürtökből – Konfigurálja a Container Insights-ügynök adatgyűjtését.

További erőforrások

• Tekintse át a munkafüzetek dokumentációját , és használja az Operátor Nexus telemetriai minta operátori Nexus-munkafüzeteket.
• Tekintse át az Azure Monitor-riasztásokat, hogyan hozhat létre Azure Monitor-riasztási szabályokat, és hogyan használhatja a nexusos riasztási mintasablonokat.