Monitorování clusteru Nexus Kubernetes

Každý cluster Nexus Kubernetes se skládá z několika vrstev:

• Virtuální počítače (VM)
• Vrstva Kubernetes
• Pody aplikací

Obrázek: Ukázkový cluster Kubernetes pro Nexus

V instanci se clustery Nexus Kubernetes dodávají s volitelnýmkontejnerovým Přehledy řešení pozorovatelnosti. Kontejner Přehledy zaznamenává protokoly a metriky z clusterů a úloh Nexus Kubernetes. Je to výhradně podle vašeho uvážení, jestli chcete povolit tento nástroj nebo nasadit vlastní zásobník telemetrie.

Cluster Nexus Kubernetes s nástrojem pro monitorování Azure vypadá takto:

Obrázek: Cluster Nexus Kubernetes s nástroji pro monitorování

Onboarding rozšíření pomocí rozhraní příkazového řádku s využitím ověřování spravované identity

Dokumentace pro spuštění Azure CLI, postup instalace v různých operačních systémech a postup instalace rozšíření rozhraní příkazového řádku

Nainstalujte nejnovější verzi potřebných rozšíření rozhraní příkazového řádku.

Monitorování clusteru Nexus Kubernetes – vrstva virtuálního počítače

Tento průvodce postupy obsahuje kroky a skripty nástrojů pro připojení clusteru Nexus Kubernetes k Azure a povolení agentů monitorování pro shromažďování systémových protokolů z těchto virtuálních počítačů pomocí agenta monitorování Azure. Pokyny dále zaznamenávají podrobnosti o tom, jak nastavit shromažďování dat protokolu do pracovního prostoru služby Log Analytics.

Následující zdroje informací poskytují podporu:

• arc-connect.env: Tento soubor šablony použijte k vytvoření proměnných prostředí potřebných zahrnutými skripty.

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: Pomocí tohoto skriptu vytvořte pravidlo shromažďování dat (DCR) ke konfiguraci shromažďování syslogu.

#!/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: Pomocí skriptu vytvořte zásadu pro přidružení DCR ke všem serverům s podporou Arc ve skupině prostředků.

#!/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: Nainstalujte na každý virtuální počítač agenta Monitorování Azure, abyste mohli shromažďovat data monitorování ze služby Azure Virtual Machines.

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

Požadavky na virtuální počítač

• Přístup správce clusteru ke clusteru Nexus Kubernetes

• Pokud chcete používat servery s podporou Azure Arc, zaregistrujte ve svém předplatném následující poskytovatele prostředků Azure:

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

Pokud jste to ještě neudělali, zaregistrujte tyto poskytovatele prostředků:

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'

• Podle potřeby přiřaďte instanční objekt Azure k následujícím předdefinovaným rolím Azure. Přiřaďte instanční objekt skupině prostředků Azure, která má počítače, které se mají připojit:

Role	Potřebné pro
Prostředek počítače Azure Připojení Správa istrator nebo přispěvatel	Připojení serveru clusteru Nexus Kubernetes s podporou arc ve skupině prostředků a instalaci agenta monitorování Azure (AMA)
Přispěvatel monitorování nebo přispěvatel	Vytvořte ve skupině prostředků pravidlo shromažďování dat (DCR) a přidružte k němu servery s podporou Arc.
Uživatelský přístup Správa istrator a přispěvatel zásad prostředků nebo přispěvatel	Potřeba, pokud chcete použít přiřazení zásad Azure, abyste zajistili, že je dcR přidružený k počítačům s podporou Arc.
Přispěvatel rozšíření Kubernetes	Potřeba k nasazení rozšíření K8s pro container Přehledy

Nastavení prostředí

Zkopírujte a spusťte zahrnuté skripty. Můžete je spustit z Azure Cloud Shellu na webu Azure Portal. Nebo je můžete spustit z příkazového řádku Linuxu, kde je nainstalovaný nástroj příkazového řádku Kubernetes (kubectl) a Azure CLI.

Před spuštěním zahrnutých skriptů definujte následující proměnné prostředí:

Proměnná prostředí	Popis
SUBSCRIPTION_ID	ID předplatného Azure, které obsahuje skupinu prostředků
RESOURCE_GROUP	Název skupiny prostředků, ve které se vytvoří server s podporou arc a přidružené prostředky
UMÍSTĚNÍ	Oblast Azure, ve které se vytvářejí servery s podporou Arc a přidružené prostředky
SERVICE_PRINCIPAL_ID	AppId instančního objektu Azure s příslušnými přiřazeními rolí
SERVICE_PRINCIPAL_SECRET	Ověřovací heslo pro instanční objekt Azure
TENANT_ID	ID adresáře tenanta, ve kterém existuje instanční objekt.
PROXY_URL	Adresa URL proxy serveru, která se má použít pro připojení ke službám Azure
OBOR NÁZVŮ	Obor názvů, ve kterém se vytvářejí artefakty Kubernetes

Pro usnadnění můžete upravit soubor arc-connect.envšablony a nastavit hodnoty proměnných prostředí.

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

Přidání pravidla shromažďování dat (DCR)

Přidružte servery s podporou Arc k řadiči domény, aby bylo možné shromažďování dat protokolu do pracovního prostoru služby Log Analytics. DcR můžete vytvořit prostřednictvím webu Azure Portal nebo rozhraní příkazového řádku. Informace o vytvoření DCR pro shromažďování dat z virtuálních počítačů jsou k dispozici tady.

Zahrnutý dcr.sh skript vytvoří řadič domény v zadané skupině prostředků, která nakonfiguruje shromažďování protokolů.

1. Zajistěte správné nastavení prostředí a předpoklady role pro instanční objekt. Řadič domény se vytvoří v zadané skupině prostředků.

2. Vytvořte nebo identifikujte pracovní prostor služby Log Analytics pro příjem dat protokolů podle dcR. Nastavte proměnnou prostředí LAW_RESOURCE_ID na ID prostředku. Načtěte ID prostředku pro známý název pracovního prostoru služby Log Analytics:

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

3. Spusťte dcr.sh skript. Vytvoří řadič domény v zadané skupině prostředků s názvem ${RESOURCE_GROUP}-syslog-dcr.

./dcr.sh

Zobrazení nebo správa DCR z webu Azure Portal nebo rozhraní příkazového řádku Ve výchozím nastavení je úroveň protokolu Syslog linuxu nastavená na INFO. Úroveň protokolu můžete podle potřeby změnit.

Poznámka:

Ručně nebo prostřednictvím zásady přidružte servery vytvořené před vytvořením DCR. Viz úloha nápravy.

Přidružení prostředků serveru s podporou Arc k DCR

Přidružte prostředky serveru s podporou Arc k vytvořenému řadiči domény pro tok protokolů do pracovního prostoru služby Log Analytics. Existují možnosti přidružení serverů k řadičům domény.

Přidružení vybraných serverů s podporou Arc k DCR pomocí webu Azure Portal nebo rozhraní příkazového řádku

Na webu Azure Portal přidejte prostředek serveru s podporou arc do DCR pomocí jeho oddílu Prostředky.

Pomocí tohoto odkazu můžete získat informace o přidružení prostředků prostřednictvím Azure CLI.

Použití služby Azure Policy ke správě přidružení DCR

Přiřaďte skupině prostředků zásadu, která vynucuje přidružení. K dispozici je integrovaná definice zásad, která přidruží počítače Se službou Arc Pro Linux k řadiči domény. Přiřaďte zásadu ke skupině prostředků pomocí DCR jako parametr. Zajišťuje přidružení všech serverů s podporou arc v rámci skupiny prostředků se stejným dcR.

Na webu Azure Portal vyberte Assign tlačítko ze stránky definice zásad.

Pro usnadnění přístupu přiřadí zadaný assign.sh skript předdefinované zásady zadané skupině prostředků a řadiči domény vytvořené pomocí dcr.sh skriptu.

1. Zajistěte, aby instanční objekt správně nastavil prostředí a požadavky na role, aby mohli provádět zásady a přiřazení rolí.
2. Ve skupině prostředků vytvořte dcR pomocí dcr.sh skriptu, jak je popsáno v části Přidání pravidla shromažďování dat.
3. Spusťte skript assign.sh. Vytvoří přiřazení zásad a potřebná přiřazení rolí.

./assign.sh

Instalace agenta monitorování Azure

Použijte zahrnuté install.sh , které vytvoří daemonSet Kubernetes v clusteru Nexus Kubernetes. Nasadí pod do každého uzlu clusteru a nainstaluje agenta monitorování Azure (AMA). Zahrnuje daemonSet také sondu aktivity, která monitoruje připojení k serveru a procesy AMA.

Poznámka:

Pokud chcete nainstalovat agenta Azure Monitoring Agent, musíte nejprve připojit virtuální počítače clusteru Nexus Kubernetes arc. Tento proces se automatizuje, pokud používáte nejnovější sadu verzí. Pokud ale sada verzí, kterou používáte, ve výchozím nastavení nepodporuje registraci virtuálních počítačů Arc clusteru, budete muset cluster upgradovat na nejnovější sadu verzí. Další informace o sadě verzí najdete v tématu Podporované verze clusteru Nexus Kubernetes.

1. Nastavte prostředí podle toho, jak je uvedeno v nastavení prostředí. Nastavte aktuální kubeconfig kontext pro virtuální počítače clusteru Nexus Kubernetes.
2. Povolte Kubectl přístup ke clusteru Nexus Kubernetes.

   Poznámka:

   Při vytváření clusteru Nexus Kubernetes vytvoří Nexus automaticky spravovanou skupinu prostředků vyhrazenou k ukládání prostředků clusteru v rámci této skupiny, vytvoří se prostředek clusteru připojeného ke službě Arc.

   Pokud chcete získat přístup ke clusteru, musíte nastavit připojení kubeconfigclusteru . Po přihlášení k Azure CLI s příslušnou entitou Microsoft Entra můžete získat kubeconfig potřebnou komunikaci s clusterem odkudkoli, i mimo bránu firewall, která ji obklopuje.

   1. RESOURCE_GROUP Nastavte CLUSTER_NAMEa SUBSCRIPTION_ID proměnné.

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

   2. Dotazování spravované skupiny prostředků pomocí az a uložení do 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. Následující příkaz spustí proxy server connectedk8s, který umožňuje připojit se k serveru rozhraní API Kubernetes pro zadaný cluster Nexus Kubernetes.

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

   4. Slouží kubectl k odesílání požadavků do clusteru:

      kubectl get pods -A
      

      Teď by se měla zobrazit odpověď z clusteru obsahujícího seznam všech uzlů.

   Poznámka:

   Pokud se zobrazí chybová zpráva "Nepodařilo se odeslat přístupový token do klientského proxy serveru se nepovedlo připojit k MSI", možná budete muset provést az login opětovné ověření v Azure.

3. install.sh Spusťte skript z příkazového řádku s přístupem kubectl ke clusteru Nexus Kubernetes.

Skript nasadí cluster daemonSet . Průběh sledujte následujícím způsobem:

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

Po dokončení systém zaznamená zprávu "Monitorování serveru bylo úspěšně nakonfigurováno".

Poznámka:

Přidružte tyto připojené servery k řadiči domény. Po nakonfigurování zásady může dojít ke zpoždění sledování protokolů v pracovním prostoru služby Azure Log Analytics.

Monitorování clusteru Nexus Kubernetes – vrstva K8s

Požadavky – Kubernetes

Operátor musí mít jistotu, že nakonfiguruje monitorovací nástroje v clusterech Kubernetes Nexus.

Kontejner Přehledy ukládá svá data do pracovního prostoru služby Log Analytics. Protokolují data do pracovního prostoru, jehož ID prostředku jste zadali během počátečních skriptů popsaných v části Přidání pravidla shromažďování dat (DCR). Jinak se trychtýřová data do výchozího pracovního prostoru ve skupině prostředků přidružené k vašemu předplatnému (na základě umístění Azure).

Příklad pro USA – východ může vypadat takto:

• Název pracovního prostoru služby Log Analytics: DefaultWorkspace-GUID-EUS<>
• Název skupiny prostředků: DefaultResourceGroup-EUS

Spuštěním následujícího příkazu získejte ID prostředku existujícího pracovního prostoru služby Log Analytics:

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

Nasazení kontejneru Přehledy a zobrazení dat v příslušném pracovním prostoru služby Log Analytics vyžaduje určitá přiřazení rolí ve vašem účtu. Například přiřazení role Přispěvatel. Projděte si pokyny pro přiřazení požadovaných rolí:

• Role Přispěvatel Log Analytics: Potřebná oprávnění k povolení monitorování kontejnerů v clusteru CNF (zřízeném).
• Role Čtenář Log Analytics: Nečlenové role přispěvatele Log Analytics obdrží oprávnění k zobrazení dat v pracovním prostoru služby Log Analytics, jakmile povolíte monitorování kontejnerů.

Instalace rozšíření clusteru

Přihlaste se ke službě Azure Cloud Shell pro přístup ke clusteru:

az login

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

Teď nasaďte rozšíření Container Přehledy do zřízeného clusteru Nexus Kubernetes pomocí některého z následujících dvou příkazů:

S předem vytvořeným pracovním prostorem Log Analytics zákazníka

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

Použití výchozího pracovního prostoru služby Log Analytics

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

Ověření rozšíření clusteru

Pomocí následujícího příkazu ověřte úspěšné nasazení povolení agentů monitorování v clusterech Nexus Kubernetes:

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

Vyhledejte stav zřizování úspěšného rozšíření. Příkaz "k8s-extension create" mohl také vrátit stav.

Přizpůsobení shromažďování protokolů a metrik

Kontejnerová Přehledy poskytuje koncovým uživatelům funkce pro vyladění shromažďování protokolů a metrik z clusterů Nexus Kubernetes – Konfigurace shromažďování dat agenta Container Insights.

Další zdroje informací

• Projděte si dokumentaci k sešitům a pak můžete použít ukázkové sešity Operátor Nexus telemetrie Operátor Nexus.
• Projděte si upozornění služby Azure Monitor, jak vytvořit pravidla upozornění služby Azure Monitor a jak používat ukázkové šablony upozornění Nexus operátora.