Memantau kluster Nexus Kubernetes
Setiap kluster Nexus Kubernetes terdiri dari beberapa lapisan:
- Komputer Virtual (VM)
- Lapisan Kubernetes
- Pod aplikasi
Gambar: Contoh kluster Nexus Kubernetes
Pada instans, kluster Nexus Kubernetes dikirimkan dengan solusi observabilitas Container Insights opsional. Container Insights mengambil log dan metrik dari kluster dan beban kerja Nexus Kubernetes. Ini hanya kebijaksanaan Anda apakah akan mengaktifkan alat ini atau menyebarkan tumpukan telemetri Anda sendiri.
Kluster Nexus Kubernetes dengan alat pemantauan Azure terlihat seperti:
Gambar: Kluster Nexus Kubernetes dengan Alat Pemantauan
Onboarding ekstensi dengan CLI menggunakan autentikasi identitas terkelola
Dokumentasi untuk dimulai dengan Azure CLI, cara menginstalnya di beberapa sistem operasi, dan cara menginstal ekstensi CLI.
Instal versi terbaru ekstensi CLI yang diperlukan.
Memantau kluster Nexus Kubernetes – Lapisan VM
Panduan cara ini menyediakan langkah-langkah dan skrip utilitas ke Arc menghubungkan Kluster Nexus Kubernetes Virtual Machines ke Azure dan memungkinkan agen pemantauan untuk pengumpulan log Sistem dari VM ini menggunakan Azure Monitoring Agent. Instruksi selanjutnya menangkap detail tentang cara menyiapkan pengumpulan data log ke ruang kerja Analitik Log.
Sumber daya berikut memberi Anda dukungan:
arc-connect.env
: gunakan file templat ini untuk membuat variabel lingkungan yang diperlukan oleh skrip yang disertakan
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
: gunakan skrip ini untuk membuat Aturan Pengumpulan Data (DCR) untuk mengonfigurasi pengumpulan syslog
#!/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
: gunakan skrip untuk membuat kebijakan untuk mengaitkan DCR dengan semua server berkemampuan Arc dalam grup sumber daya
#!/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
: Instal Azure Monitoring Agent pada setiap VM untuk mengumpulkan data pemantauan dari 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
Prasyarat-VM
Akses administrator kluster ke kluster Nexus Kubernetes.
Untuk menggunakan server dengan dukungan Azure Arc, daftarkan penyedia sumber daya Azure berikut ini di langganan Anda:
- Microsoft.HybridCompute
- Microsoft.GuestConfiguration
- Microsoft.HybridConnectivity
Daftarkan penyedia sumber daya ini, jika tidak dilakukan sebelumnya:
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'
- Tetapkan perwakilan layanan Azure ke peran bawaan Azure berikut, sesuai kebutuhan. Tetapkan perwakilan layanan ke grup sumber daya Azure yang memiliki komputer yang akan disambungkan:
Peran | Diperlukan untuk |
---|---|
Administrator atau Kontributor Sumber Daya Azure Connected Machine | Sambungkan server VM kluster Nexus Kubernetes dengan dukungan Arc di grup sumber daya dan instal Azure Monitoring Agent (AMA) |
Kontributor atau Kontributor Pemantauan | Membuat Aturan Pengumpulan Data (DCR) di grup sumber daya dan mengaitkan server dengan dukungan Arc ke dalamnya |
Administrator Akses Pengguna, dan Kontributor atau Kontributor Kebijakan Sumber Daya | Diperlukan jika Anda ingin menggunakan penetapan kebijakan Azure untuk memastikan bahwa DCR dikaitkan dengan komputer berkemampuan Arc |
Kontributor Ekstensi Kubernetes | Diperlukan untuk menyebarkan ekstensi K8s untuk Container Insights |
Penyiapan lingkungan
Salin dan jalankan skrip yang disertakan. Anda dapat menjalankannya dari Azure Cloud Shell, di portal Azure. Atau Anda dapat menjalankannya dari prompt perintah Linux tempat alat baris perintah Kubernetes (kubectl) dan Azure CLI diinstal.
Sebelum menjalankan skrip yang disertakan, tentukan variabel lingkungan berikut:
Variabel lingkungan | Deskripsi |
---|---|
SUBSCRIPTION_ID | ID langganan Azure yang berisi grup sumber daya |
RESOURCE_GROUP | Nama grup sumber daya tempat server yang didukung Arc dan sumber daya terkait dibuat |
LOKASI | Wilayah Azure tempat server yang diaktifkan Arc dan sumber daya terkait dibuat |
SERVICE_PRINCIPAL_ID | AppId dari perwakilan layanan Azure dengan penetapan peran yang sesuai |
SERVICE_PRINCIPAL_SECRET | Kata sandi autentikasi untuk perwakilan layanan Azure |
TENANT_ID | ID direktori penyewa tempat perwakilan layanan berada |
PROXY_URL | URL proksi yang digunakan untuk menyambungkan ke layanan Azure |
NAMESPACE | Namespace tempat artefak Kubernetes dibuat |
Untuk kenyamanan, Anda dapat memodifikasi file templat, arc-connect.env
, untuk mengatur nilai variabel lingkungan.
# Apply the modified values to the environment
./arc-connect.env
Menambahkan aturan pengumpulan data (DCR)
Kaitkan server berkemampuan Arc dengan DCR untuk mengaktifkan pengumpulan data log ke ruang kerja Analitik Log. Anda dapat membuat DCR melalui portal Azure atau CLI. Informasi tentang membuat DCR untuk mengumpulkan data dari VM tersedia di sini.
Skrip yang disertakan dcr.sh
membuat DCR, dalam grup sumber daya yang ditentukan, yang akan mengonfigurasi pengumpulan log.
Pastikan pengaturan lingkungan dan prasyarat peran yang tepat untuk perwakilan layanan. DCR dibuat dalam grup sumber daya yang ditentukan.
Membuat atau mengidentifikasi ruang kerja Analitik Log untuk penyerapan data log sesuai DCR. Atur variabel lingkungan, LAW_RESOURCE_ID ke ID sumber dayanya. Ambil ID sumber daya untuk nama ruang kerja Analitik Log yang diketahui:
export LAW_RESOURCE_ID=$(az monitor log-analytics workspace show -g "${RESOURCE_GROUP}" -n <law name> --query id -o tsv)
- Jalankan skrip dcr.sh. Ini membuat DCR dalam grup sumber daya yang ditentukan dengan nama ${RESOURCE_GROUP}-syslog-dcr
./dcr.sh
Lihat/kelola DCR dari portal Azure atau CLI. Secara default, tingkat log Linux Syslog diatur ke "INFO". Anda dapat mengubah tingkat log sesuai kebutuhan.
Catatan
Secara manual, atau melalui kebijakan, mengaitkan server yang dibuat sebelum pembuatan DCR. Lihat tugas remediasi.
Mengaitkan sumber daya server dengan dukungan Arc ke DCR
Kaitkan sumber daya server dengan dukungan Arc ke DCR yang dibuat agar log mengalir ke ruang kerja Analitik Log. Ada opsi untuk mengaitkan server dengan DCR.
Gunakan portal Azure atau CLI untuk mengaitkan server berkemampuan Arc yang dipilih ke DCR
Di portal Azure, tambahkan sumber daya server dengan dukungan Arc ke DCR menggunakan bagian Sumber Dayanya.
Gunakan tautan ini untuk informasi tentang mengaitkan sumber daya melalui Azure CLI.
Menggunakan kebijakan Azure untuk mengelola asosiasi DCR
Tetapkan kebijakan ke grup sumber daya untuk memberlakukan asosiasi. Ada definisi kebijakan bawaan, untuk mengaitkan Linux Arc Machines dengan DCR. Tetapkan kebijakan ke grup sumber daya dengan DCR sebagai parameter. Ini memastikan asosiasi semua server berkemampuan Arc, dalam grup sumber daya, dengan DCR yang sama.
Di portal Azure, pilih tombol Assign
dari halaman definisi kebijakan.
Untuk kenyamanan, skrip yang disediakan assign.sh
menetapkan kebijakan bawaan ke grup sumber daya yang ditentukan dan DCR yang dibuat dengan dcr.sh
skrip.
- Pastikan pengaturan lingkungan dan prasyarat peran yang tepat bagi perwakilan layanan untuk melakukan kebijakan dan penetapan peran.
- Buat DCR, di grup sumber daya, menggunakan
dcr.sh
skrip seperti yang dijelaskan di bagian Menambahkan Aturan Pengumpulan Data. - Jalankan
assign.sh
skrip. Ini membuat penetapan kebijakan dan penetapan peran yang diperlukan.
./assign.sh
Menginstal agen pemantauan Azure
Gunakan yang disertakan install.sh
yang membuat daemonSet Kubernetes pada kluster Nexus Kubernetes.
Ini menyebarkan pod ke setiap node kluster dan menginstal Azure Monitoring Agent (AMA).
Juga daemonSet
termasuk pemeriksaan keaktifan yang memantau koneksi server dan proses AMA.
Catatan
Untuk menginstal Azure Monitoring Agent, Anda harus terlebih dahulu menghubungkan VM kluster Nexus Kubernetes. Proses ini diotomatisasi jika Anda menggunakan bundel versi terbaru. Namun, jika bundel versi yang Anda gunakan tidak mendukung pendaftaran Arc VM kluster secara default, Anda harus meningkatkan kluster Anda ke bundel versi terbaru. Untuk informasi lebih lanjut tentang bundel versi, silakan lihat versi yang didukung kluster Nexus Kubernetes
- Atur lingkungan seperti yang ditentukan dalam Penyiapan Lingkungan. Atur konteks saat ini
kubeconfig
untuk VM kluster Nexus Kubernetes. - Izinkan
Kubectl
akses ke kluster Nexus Kubernetes.Catatan
Saat Anda membuat kluster Nexus Kubernetes, Nexus secara otomatis membuat grup sumber daya terkelola yang didedikasikan untuk menyimpan sumber daya kluster, dalam grup ini, sumber daya kluster yang terhubung dengan Arc dibuat.
kubeconfig
kluster . Setelah masuk ke Azure CLI dengan entitas Microsoft Entra yang relevan, Anda dapat memperoleh yangkubeconfig
diperlukan untuk berkomunikasi dengan kluster dari mana saja, bahkan di luar firewall yang mengelilinginya.Atur
CLUSTER_NAME
variabel ,RESOURCE_GROUP
danSUBSCRIPTION_ID
.CLUSTER_NAME="myNexusK8sCluster" RESOURCE_GROUP="myResourceGroup" SUBSCRIPTION_ID=<set the correct subscription_id>
Mengkueri grup sumber daya terkelola dengan
az
dan menyimpan diMANAGED_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)
Perintah berikut memulai proksi connectedk8s yang memungkinkan Anda terhubung ke server API Kubernetes untuk kluster Nexus Kubernetes yang ditentukan.
az connectedk8s proxy -n $CLUSTER_NAME -g $MANAGED_RESOURCE_GROUP &
Gunakan
kubectl
untuk mengirim permintaan ke kluster:kubectl get pods -A
Anda sekarang akan melihat respons dari kluster yang berisi daftar semua simpul.
Catatan
Jika Anda melihat pesan kesalahan "Gagal memposting token akses ke proxy KlienFailed untuk terhubung ke MSI", Anda mungkin perlu melakukan autentikasi
az login
ulang dengan Azure. - Jalankan
install.sh
skrip dari prompt perintah dengan akses kubectl ke kluster Nexus Kubernetes.
Skrip menyebarkan daemonSet
ke kluster. Pantau kemajuannya sebagai berikut:
# Run the install script and observe results
./install.sh
kubectl get pod --selector='name=naks-vm-telemetry'
kubectl logs <podname>
Setelah selesai, sistem mencatat pesan "Pemantauan server berhasil dikonfigurasi".
Catatan
Kaitkan server yang terhubung ini ke DCR. Setelah Anda mengonfigurasi kebijakan, mungkin ada beberapa penundaan untuk mengamati log di Ruang Kerja Azure Log Analytics
Memantau kluster Nexus Kubernetes – Lapisan K8s
Prasyarat-Kubernetes
Ada prasyarat tertentu yang harus dipastikan operator untuk mengonfigurasi alat pemantauan pada Kluster Kubernetes Nexus.
Container Insights menyimpan datanya di ruang kerja Analitik Log. Data log mengalir ke ruang kerja yang ID Sumber Dayanya Anda berikan selama skrip awal yang tercakup di bagian "Tambahkan aturan pengumpulan data (DCR)" . Jika tidak, corong data ke ruang kerja default di grup Sumber Daya yang terkait dengan langganan Anda (berdasarkan lokasi Azure).
Contoh untuk US Timur mungkin terlihat seperti berikut:
- Nama ruang kerja Analitik Log: DefaultWorkspace-GUID-EUS<>
- Nama grup sumber daya: DefaultResourceGroup-EUS
Jalankan perintah berikut untuk mendapatkan ID Sumber Daya ruang kerja Analitik Log yang sudah ada sebelumnya:
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
Untuk menyebarkan Wawasan Kontainer dan melihat data di ruang kerja Analitik Log yang berlaku memerlukan penetapan peran tertentu di akun Anda. Misalnya, penetapan peran "Kontributor". Lihat instruksi untuk menetapkan peran yang diperlukan:
- Peran Kontributor Analitik Log: izin yang diperlukan untuk mengaktifkan pemantauan kontainer pada kluster CNF (disediakan).
- Peran Pembaca Analitik Log: non-anggota peran Kontributor Analitik Log, menerima izin untuk melihat data di ruang kerja Analitik Log setelah Anda mengaktifkan pemantauan kontainer.
Menginstal ekstensi kluster
Masuk ke Azure Cloud Shell untuk mengakses kluster:
az login
az account set --subscription "<Subscription Name or ID the Provisioned Cluster is in>"
Sekarang, sebarkan ekstensi Container Insights pada kluster Nexus Kubernetes yang disediakan menggunakan salah satu dari dua perintah berikutnya:
Dengan ruang kerja Analitik log yang telah dibuat sebelumnya kepada pelanggan
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
Menggunakan ruang kerja analitik Log default
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
Memvalidasi ekstensi Kluster
Validasi keberhasilan penyebaran pengaktifan agen pemantauan pada Kluster Kubernetes Nexus menggunakan perintah berikut:
az k8s-extension show --name azuremonitor-containers \
--cluster-name "<Nexus Kubernetes cluster Name>" \
--resource-group "<Nexus Kubernetes cluster Resource Group>" \
--cluster-type connectedClusters
Cari Status Provisi "Berhasil" untuk ekstensi. Perintah "k8s-extension create" mungkin juga mengembalikan status.
Menyesuaikan pengumpulan log & metrik
Container Insights menyediakan fungsionalitas pengguna akhir untuk menyempurnakan pengumpulan log dan metrik dari Kluster Nexus Kubernetes--Mengonfigurasi pengumpulan data agen wawasan Kontainer.
Sumber daya ekstra
- Tinjau dokumentasi buku kerja lalu Anda dapat menggunakan sampel telemetri Operator Nexus Operator buku kerja Nexus.
- Tinjau Pemberitahuan Azure Monitor, cara membuat aturan Pemberitahuan Azure Monitor, dan menggunakan contoh templat Pemberitahuan Nexus Operator.