Ինչպես տեղադրել Elasticsearch, Fluentd և Kibana (EFK) Logging Stack-ը Ubuntu 22.04-ում

Այս էջում

Նախադրյալներ
Քայլ 1 - Կարգավորել Firewall-ը
Քայլ 2 - Տեղադրեք Docker-ը և Docker Compose-ը
Քայլ 3 - Ստեղծեք Docker Compose ֆայլ
Քայլ 4 - Ստեղծեք Fluentd Build ֆայլեր
Քայլ 5 - Գործարկեք Docker Containers-ը
Քայլ 6 - Կարգավորել Kibana-ն
Քայլ 7 - Տեղադրեք Nginx
Քայլ 8 - Տեղադրեք SSL-ը
Քայլ 9 - Կարգավորեք Nginx-ը
Քայլ 10 - Docker կոնտեյների գործարկում Fluentd Log Driver-ով
Եզրակացություն

Մատյանների մոնիտորինգը և վերլուծությունը սերվերի կամ կոնտեյներային ենթակառուցվածքի էական մասն են և օգտակար են բարդ հավելվածների հետ աշխատելիս: Հանրաճանաչ անտառահատումների լուծումներից մեկը Elasticsearch, Fluentd և Kibana (EFK) ստեկն է: Նախքան ձեռնարկին հետագա անցնելը, եկեք իմանանք փաթեթի բաղադրիչների մասին:

Elasticsearch-ը իրական ժամանակի, բաշխված և մասշտաբային որոնման համակարգ է, որը թույլ է տալիս ամբողջական տեքստի որոնում և վերլուծություն: Այն օգտագործվում է մեծ քանակությամբ տվյալների ինդեքսավորման և որոնման համար: Այն սովորաբար տեղադրվում է Kibana-ի կողքին՝ Elasticsearch-ի տվյալների վիզուալացման հզոր վահանակ: Kibana-ն թույլ է տալիս ուսումնասիրել Elasticsearch-ի մատյանների տվյալները և ստեղծել վահանակներ և հարցումներ՝ ձեր հավելվածի վերաբերյալ պատկերացում կազմելու համար: Fluentd-ը հավաքում, փոխակերպում և ուղարկում է տեղեկամատյանների տվյալները Elasticsearch-ի հետին պլան:

Այս ձեռնարկում մենք կտեղադրենք EFK փաթեթը Docker-ի միջոցով Ubuntu 22.04 մեքենայի վրա և բեռնարկղերի տեղեկամատյանները կուղարկենք Kibana՝ դրանք զտելուց և փոխակերպելուց հետո Fluentd-ի միջոցով:

Նախադրյալներ

Ubuntu 22.04-ով աշխատող սերվեր՝ նվազագույնը 6 ԳԲ օպերատիվ հիշողությամբ:

Ոչ արմատային օգտատեր՝ sudo արտոնություններով:

Ոչ բարդ Firewall-ը (UFW) միացված է և աշխատում է:

Լիովին որակավորված տիրույթի անուն (FQDN), որը ցույց է տալիս սերվերը, ինչպիսին է kibana.example.com:

Ամեն ինչ թարմացվում է։

$ sudo apt update && sudo apt upgrade

Քայլ 1 - Կարգավորել Firewall-ը

Նախքան որևէ փաթեթ տեղադրելը, առաջին քայլը կարգավորելն է firewall-ը, որպեսզի թույլ տա HTTP և HTTPS միացումներ:

Ստուգեք firewall-ի կարգավիճակը:

$ sudo ufw status

Դուք պետք է տեսնեք հետևյալի նման մի բան.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Թույլատրել HTTP և HTTPs նավահանգիստները:

$ sudo ufw allow http
$ sudo ufw allow https

Ստուգեք կարգավիճակը կրկին հաստատելու համար:

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Քայլ 2 - Տեղադրեք Docker-ը և Docker Compose-ը

Ավելացնել Docker-ի պաշտոնական GPG բանալին:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Գործարկեք հետևյալ հրամանը՝ Docker պահեստը ավելացնելու համար:

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Թարմացրեք համակարգը՝ ներառելու Docker-ի պահոցը:

$ sudo apt update

Տեղադրեք Docker-ը և Docker compose հավելվածը:

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Այս ձեռնարկը կօգտագործի Docker Compose v2 հավելվածը հին ժառանգական երկուականի փոխարեն: Հետևաբար, այն գործարկելու հրամանը docker-compose-ից փոխվել է docker composeև սա արտացոլված է այստեղ։

Docker-ն աշխատում է բարձր արտոնություններով, այնպես որ դուք պետք է հաճախակի օգտագործեք sudo հրամանները գործարկելու համար: Ավելի լավ տարբերակն է ավելացնել ձեր Linux օգտվողի հաշիվը docker օգտվողների խմբին:

$ sudo usermod -aG docker ${USER}

$ {USER} փոփոխականն ընտրում է ներկայումս մուտք գործած համակարգի հաշիվը: Եթե դուք մուտք չեք գործել այն օգտվողի հետ, ում ցանկանում եք արտոնություններ տալ, փոխարինեք $ {USER} օգտվողի անունով:

Խմբի նոր անդամակցության համար դիմելու համար դուրս եկեք սերվերից և նորից մուտք գործեք կամ օգտագործեք հետևյալ հրամանը. Ձեզանից կպահանջվի մուտքագրել օգտվողի գաղտնաբառը:

$ su - ${USER}

Քայլ 3 - Ստեղծեք Docker Compose ֆայլ

Նախ, ստեղծեք տեղեկատու EFK նախագծի համար:

$ mkdir ~/efk

Անցեք գրացուցակին:

$ cd ~/efk

Ստեղծեք և բացեք docker-compose.yml ֆայլը խմբագրման համար:

$ nano docker-compose.yml

Դրա մեջ տեղադրեք հետևյալ կոդը.

services:
  # Deploy using the custom image automatically be created during the build process.
  fluentd:
    build: ./fluentd
    volumes:
      - ./fluentd/conf:/fluentd/etc
    links: # Sends incoming logs to the elasticsearch container.
      - elasticsearch
    depends_on:
      - elasticsearch
    ports: # Exposes the port 24224 on both TCP and UDP protocol for log aggregation
      - 24224:24224
      - 24224:24224/udp

  elasticsearch:
    image: elasticsearch:8.7.1
    expose:
      - 9200
    environment:
      - discovery.type=single-node # Runs as a single-node
      - xpack.security.enabled=false
    volumes: # Stores elasticsearch data locally on the esdata Docker volume
      - esdata:/usr/share/elasticsearch/data

  kibana:
    image: kibana:8.7.1
    links: # Links kibana service to the elasticsearch container
      - elasticsearch
    depends_on:
      - elasticsearch
    ports:
      - 5601:5601
    environment: # Defined host configuration
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200

# Define the Docker volume named esdata for the Elasticsearch container.
volumes:
  esdata:

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է: Մենք կազմաձևել ենք երեք ծառայություն սկսելու համար՝ մեկը յուրաքանչյուրի համար՝ Fluentd, Elasticsearch և Kibana:

Fluentd-ի համար մենք պատրաստի պատկերի փոխարեն կոնտեյներ կկառուցենք: Fluentd-ի կառուցման ֆայլերը կստեղծվեն հաջորդ քայլում: Մենք տեղադրեցինք գրացուցակ իր կառուցված ֆայլերի համար, և ծավալ՝ կազմաձևման ֆայլերի համար, և բացեցինք 24224 նավահանգիստը և՛ TCP, և՛ UDP արձանագրության վրա՝ տեղեկամատյանների ագրեգացման համար:

Հաջորդ ծառայությունը Elasticsearchն է, և մենք օգտագործում ենք այս ձեռնարկը գրելու պահին հասանելի վերջին տարբերակը: Մենք այն բացահայտել ենք 9200 պորտի միջոցով և ստեղծել ենք մի քանի միջավայրի փոփոխականներ, որպեսզի կարողանանք այն գործարկել որպես մեկ հանգույցի կլաստեր և անջատել ենք անվտանգության առանձնահատկությունները: Սա սովորաբար խորհուրդ չի տրվում, սակայն անվտանգության ակտիվացումը դուրս է այս ձեռնարկի շրջանակներից: Մենք նաև տեղադրել ենք տեղական ծավալ՝ Elasticsearch տվյալների համար:

Վերջապես, մենք կարգավորում ենք Kibana-ը և ցուցադրում այն 5601 պորտի միջոցով, որը կօգտագործվի վահանակ մուտք գործելու համար: Մենք նաև ստեղծեցինք փոփոխական՝ կարգավորելու Elasticsearch հոսթը, որպեսզի այն կարողանա մուտք գործել:

Քայլ 4 - Ստեղծեք Fluentd Build ֆայլեր

Ստեղծեք Fluentd-ը և կազմաձևման գրացուցակը:

$ mkdir fluentd/conf -p

Գործարկեք tree հրամանը՝ գրացուցակի կառուցվածքը ստուգելու համար:

$ tree

Այն պետք է նմանվի հետևյալին.

Անցեք Fluentd գրացուցակին:

$ cd fluentd

Ստեղծեք և բացեք Dockerfile խմբագրման համար:

$ nano Dockerfile

Դրա մեջ տեղադրեք հետևյալ կոդը. Այս կոդը քաշում է Fluentd Debian Docker պատկերը և տեղադրում Fluentd հավելվածը Elasticsearch-ի համար։

# fluentd/Dockerfile
FROM fluent/fluentd:v1.16-debian-1
USER root
RUN ["gem", "install", "fluent-plugin-elasticsearch", "--no-document", "--version", "5.3.0"]
USER fluent

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Անցեք կազմաձևման գրացուցակին:

$ cd conf

Ստեղծեք և բացեք fluentd.conf ֆայլը խմբագրման համար:

$ nano fluentd.conf

Դրա մեջ տեղադրեք հետևյալ կոդը.

# bind fluentd on IP 0.0.0.0
# port 24224
<source>
  @type forward
  port 24224
  bind 0.0.0.0
</source>

# sendlog to the elasticsearch
# the host must match to the elasticsearch
# container service
<match *.**>
  @type copy
  <store>
    @type elasticsearch_dynamic
    hosts elasticsearch:9200
    logstash_format true
    logstash_prefix fluentd
    logstash_dateformat %Y%m%d
    include_tag_key true
    tag_key @log_name
    include_timestamp true
    flush_interval 30s
  </store>
  <store>
    @type stdout
  </store>
</match>

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ պահանջվում է:

Վերևի աղբյուր հրահանգը օգտագործում է forward հավելվածը, որը Fluentd-ը վերածում է TCP վերջնակետի՝ TCP փաթեթներն ընդունելու համար:

match հրահանգը փնտրում է իրադարձություններ համապատասխան պիտակներով, ինչը այս դեպքում նշանակում է, որ այն համապատասխանում է բոլոր իրադարձություններին: Պահպանման համար մենք կօգտագործենք elasticsearch_dynamic հավելվածը, որը թույլ է տալիս դինամիկ կերպով նշել կազմաձևման արժեքները: hosts դաշտը նշում է Elasticsearch հավելվածի հոսթի անունը, որը ծառայության անունն է Docker compose ֆայլում: logstash_format սահմանվել է true, ինչը նշանակում է, որ Fluentd-ն օգտագործում է անվանման պայմանական ձևաչափը logstash-%Y.%m.%dlogstash-%Y.%m.%d: Իրադարձությունները գրելու նախածանցի անունը դրված է fluend: include_tag_key-ը սահմանվել է true, որն ավելացնում է Fluentd թեգը JSON ձևաչափով: tag_key դաշտի անունն է, որը պետք է հանվի պիտակի համար: include_timestamp փոփոխականը true սահմանելով ժամանակագրության դաշտ է ավելացնում գրանցամատյանը: flush_interval-ը սահմանում է տվյալների հոսքերի միջև ընկած ժամանակահատվածը: Մենք նաև օգտագործում ենք stdout հավելվածը` իրադարձությունները/տեղեկամատյանները ստանդարտ ելքի վրա տպելու համար:

Քայլ 5 - Գործարկեք Docker Containers-ը

Վերադարձ դեպի EFK գրացուցակ։

$ cd ~/efk

Սկսեք բեռնարկղերը՝ օգտագործելով հետևյալ հրամանը.

$ docker compose up -d

Ստուգեք գործող բեռնարկղերի կարգավիճակը:

$ docker ps
b3780c311154   efk-fluentd           "tini -- /bin/entryp…"   9 seconds ago   Up 8 seconds   5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp   efk-fluentd-1
5a48f0a9ade1   kibana:8.7.1          "/bin/tini -- /usr/l…"   9 seconds ago   Up 7 seconds   0.0.0.0:5601->5601/tcp, :::5601->5601/tcp                                                                efk-kibana-1
dab3a0ab0312   elasticsearch:8.7.1   "/bin/tini -- /usr/l…"   9 seconds ago   Up 8 seconds   9200/tcp, 9300/tcp                                                                                       efk-elasticsearch-1

Դրա համար կարող եք նաև օգտագործել հետևյալ հրամանը.

$ docker compose ps
NAME                  IMAGE                 COMMAND                  SERVICE             CREATED             STATUS              PORTS
efk-elasticsearch-1   elasticsearch:8.7.1   "/bin/tini -- /usr/l…"   elasticsearch       37 seconds ago      Up 36 seconds       9200/tcp, 9300/tcp
efk-fluentd-1         efk-fluentd           "tini -- /bin/entryp…"   fluentd             37 seconds ago      Up 36 seconds       5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp
efk-kibana-1          kibana:8.7.1          "/bin/tini -- /usr/l…"   kibana              37 seconds ago      Up 36 seconds       0.0.0.0:5601->5601/tcp, :::5601->5601/tcp

Գործարկեք հետևյալ հրամանները՝ EFK-ի կառուցման գործընթացի տեղեկամատյանները ստուգելու համար:

$ docker logs efk-fluentd-1
$ docker logs efk-kibana-1
$ docker logs efk-elasticsearch-1

Ստուգեք Elasticsearch կոնտեյները: Այն կտպագրի կոնտեյների մանրամասն կարգավորումները:

$ docker inspect efk-elasticsearch-1

Դուք կարող եք նկատել կոնտեյներին տրված IP հասցեն:

[
    {
        "Id": "dab3a0ab03120d3a7192045e1ea84fdd0f8fdb7819cc6d6780e05109d61e0b66",
        "Created": "2023-05-04T09:58:00.256169904Z",
        "Path": "/bin/tini",
        "Args": [
            "--",
            "/usr/local/bin/docker-entrypoint.sh",
            "eswrapper"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 23619,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2023-05-04T09:58:00.563700803Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:59075530be34d3a06866f894ae9735f6d739a7a751ad45efb86dec3c9bd16836",
        "ResolvConfPath": "/var/lib/docker/containers/dab3a0ab03120d3a7192045e1ea84fdd0f8fdb7819cc6d6780e05109d61e0b66/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/dab3a0ab03120d3a7192045e1ea84fdd0f8fdb7819cc6d6780e05109d61e0b66/hostname",
        "HostsPath": "/var/lib/docker/containers/dab3a0ab03120d3a7192045e1ea84fdd0f8fdb7819cc6d6780e05109d61e0b66/hosts",
        "LogPath": "/var/lib/docker/containers/dab3a0ab03120d3a7192045e1ea84fdd0f8fdb7819cc6d6780e05109d61e0b66/dab3a0ab03120d3a7192045e1ea84fdd0f8fdb7819cc6d6780e05109d61e0b66-json.log",
        "Name": "/efk-elasticsearch-1",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "docker-default",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "efk_default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "ConsoleSize": [
                0,
                0
            ],
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "private",
            "Dns": null,
            "DnsOptions": null,
            "DnsSearch": null,
            "ExtraHosts": [],
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": null,
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": null,
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": null,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "Mounts": [
                {
                    "Type": "volume",
                    "Source": "efk_esdata",
                    "Target": "/usr/share/elasticsearch/data",
                    "VolumeOptions": {}
                }
            ],
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/ee03648cf34e03601848b1769569b4d3bb7192db118102ca050215ba87060bbf-init/diff:/var/lib/docker/overlay2/51d6cfcb59e473a3f163e68984a1ba1325a2c816ed7925c4dffdefcf2e104d11/diff:/var/lib/docker/overlay2/b9c096454bda31f1cb2ea33f108be8b29b2e94827ebe94cc17563eb596b7cab1/diff:/var/lib/docker/overlay2/effe604c5b015ba02cf3b7a238bd3ff5dad7970a72e689ef5275fcf03fd0bcd1/diff:/var/lib/docker/overlay2/72fbf23251467ea2f6af8d9458c7fdd8fa3ef716eeafd9319ceff59d07d96788/diff:/var/lib/docker/overlay2/02094ec9e4ebb04371f782744a3a46852a00bf6fd7e8820d466a3576aeb9d5fc/diff:/var/lib/docker/overlay2/ce364cdd636b67e10c879aa152360d965d08fe456663ed8fbe78c3bd37bde6c7/diff:/var/lib/docker/overlay2/33bf44b475ea5ea249845b7eed75ded47dd9dc7877b9231fa4195b4753071945/diff:/var/lib/docker/overlay2/4f19bd8089599ef879075012c710ec464d8e0446fc0a0813850657dddd23a5dc/diff:/var/lib/docker/overlay2/a39a61b12d8565c6d5b33c17a04d47c8bd47609a787e0548fbac0d47d00eecc8/diff:/var/lib/docker/overlay2/cbd9d77eb9ed6b600511f9a676aab511d2aa2b3dbd18d5403559699558546996/diff",
                "MergedDir": "/var/lib/docker/overlay2/ee03648cf34e03601848b1769569b4d3bb7192db118102ca050215ba87060bbf/merged",
                "UpperDir": "/var/lib/docker/overlay2/ee03648cf34e03601848b1769569b4d3bb7192db118102ca050215ba87060bbf/diff",
                "WorkDir": "/var/lib/docker/overlay2/ee03648cf34e03601848b1769569b4d3bb7192db118102ca050215ba87060bbf/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [
            {
                "Type": "volume",
                "Name": "efk_esdata",
                "Source": "/var/lib/docker/volumes/efk_esdata/_data",
                "Destination": "/usr/share/elasticsearch/data",
                "Driver": "local",
                "Mode": "z",
                "RW": true,
                "Propagation": ""
            }
        ],
        "Config": {
            "Hostname": "dab3a0ab0312",
            "Domainname": "",
            "User": "elasticsearch:root",
            "AttachStdin": false,
            "AttachStdout": true,
            "AttachStderr": true,
            "ExposedPorts": {
                "9200": {},
                "9200/tcp": {},
                "9300/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "xpack.security.enabled=false",
                "discovery.type=single-node",
                "PATH=/usr/share/elasticsearch/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "ELASTIC_CONTAINER=true"
            ],
            "Cmd": [
                "eswrapper"
            ],
            "Image": "elasticsearch:8.7.1",
            "Volumes": null,
            "WorkingDir": "/usr/share/elasticsearch",
            "Entrypoint": [
                "/bin/tini",
                "--",
                "/usr/local/bin/docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": {
                "com.docker.compose.config-hash": "51c818791aa87ea7eccc389578c76ec4d596265eba8baefb8833bf5df13777e3",
                "com.docker.compose.container-number": "1",
                "com.docker.compose.depends_on": "",
                "com.docker.compose.image": "sha256:59075530be34d3a06866f894ae9735f6d739a7a751ad45efb86dec3c9bd16836",
                "com.docker.compose.oneoff": "False",
                "com.docker.compose.project": "efk",
                "com.docker.compose.project.config_files": "/home/navjot/efk/docker-compose.yml",
                "com.docker.compose.project.working_dir": "/home/navjot/efk",
                "com.docker.compose.service": "elasticsearch",
                "com.docker.compose.version": "2.17.3",
                "org.label-schema.build-date": "2023-04-27T04:33:42.127815583Z",
                "org.label-schema.license": "Elastic-License-2.0",
                "org.label-schema.name": "Elasticsearch",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.url": "https://www.elastic.co/products/elasticsearch",
                "org.label-schema.usage": "https://www.elastic.co/guide/en/elasticsearch/reference/index.html",
                "org.label-schema.vcs-ref": "f229ed3f893a515d590d0f39b05f68913e2d9b53",
                "org.label-schema.vcs-url": "https://github.com/elastic/elasticsearch",
                "org.label-schema.vendor": "Elastic",
                "org.label-schema.version": "8.7.1",
                "org.opencontainers.image.created": "2023-04-27T04:33:42.127815583Z",
                "org.opencontainers.image.documentation": "https://www.elastic.co/guide/en/elasticsearch/reference/index.html",
                "org.opencontainers.image.licenses": "Elastic-License-2.0",
                "org.opencontainers.image.ref.name": "ubuntu",
                "org.opencontainers.image.revision": "f229ed3f893a515d590d0f39b05f68913e2d9b53",
                "org.opencontainers.image.source": "https://github.com/elastic/elasticsearch",
                "org.opencontainers.image.title": "Elasticsearch",
                "org.opencontainers.image.url": "https://www.elastic.co/products/elasticsearch",
                "org.opencontainers.image.vendor": "Elastic",
                "org.opencontainers.image.version": "8.7.1"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "bf47cd7764585766349085d35100611e086cf233fc9fc655c6eb9e086f1cd59a",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {
                "9200/tcp": null,
                "9300/tcp": null
            },
            "SandboxKey": "/var/run/docker/netns/bf47cd776458",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "",
            "Gateway": "",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "",
            "IPPrefixLen": 0,
            "IPv6Gateway": "",
            "MacAddress": "",
            "Networks": {
                "efk_default": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": [
                        "efk-elasticsearch-1",
                        "elasticsearch",
                        "dab3a0ab0312"
                    ],
                    "NetworkID": "1bc8ac0185982b84a24a201852f2cddc0432a3ffff1a2bd4008074875f696cac",
                    "EndpointID": "e1c67199e679f350d1da47f0b1e208ec6a7767eb57d60f773ba08b88a6962dcf",
                    "Gateway": "172.23.0.1",
                    "IPAddress": "172.23.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:17:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

Ինչպես տեսնում եք, կոնտեյները ստացել է 172.23.0.2 որպես IP հասցե: Գործարկեք հետևյալ հրամանը՝ ստուգելու, թե արդյոք Elasticsearch-ը ճիշտ է աշխատում:

$ curl 172.23.0.2:9200
{
  "name" : "dab3a0ab0312",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "gldMFBtQSxS5sL93rBAdzA",
  "version" : {
    "number" : "8.7.1",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "f229ed3f893a515d590d0f39b05f68913e2d9b53",
    "build_date" : "2023-04-27T04:33:42.127815583Z",
    "build_snapshot" : false,
    "lucene_version" : "9.5.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}

Քայլ 6 - Կարգավորեք Kibana-ն

Այժմ, երբ EFK ստեկը տեղակայված է, ժամանակն է կարգավորել Kibana-ն: Բրաուզերում բացեք http://:5601 URL-ը:

Կտտացրեք Իմ կողմից ուսումնասիրել կոճակը` անցնելու Kibana-ի վահանակ:

Կտտացրեք Stack Management հղումը՝ Kibana տվյալների դիտումը կարգավորելու համար: Ձախ կողագոտուց ընտրեք Kibana >> Data Views տարբերակը՝ տվյալների դիտման էջը բացելու համար:

Շարունակելու համար սեղմեք Ստեղծել տվյալների դիտում կոճակը:

Մուտքագրեք տվյալների տեսքի անունը և ինդեքսի օրինաչափությունը որպես fluentd-*: Համոզվեք, որ Timestamp դաշտը սահմանված է @timestamp: Աղբյուրի դաշտը ավտոմատ կերպով կթարմացվի: Սեղմեք Տվյալների դիտումը Kibana-ում կոճակը՝ տվյալների տեսքի ստեղծումն ավարտելու համար:

Հաջորդը, սեղմեք վերևի ցանկի վրա (էլիպսիս) և սեղմեք Բացահայտեք տարբերակը՝ տեղեկամատյանների մոնիտորինգը ցուցադրելու համար:

Դուք կստանաք հետևյալ էջը, որը հաստատում է, որ ձեր կարգավորումն անթերի է աշխատում: Տեղեկամատյանները բոլորը վերցված են Elasticsearch-ից և առաքվում են Fluentd տեղեկամատյանների ագրեգացիայի կողմից:

Քայլ 7 - Տեղադրեք Nginx

Ubuntu 22.04-ը մատակարարվում է Nginx-ի ավելի հին տարբերակով: Վերջին տարբերակը տեղադրելու համար անհրաժեշտ է ներբեռնել պաշտոնական Nginx պահոցը:

Ներմուծեք Nginx-ի ստորագրման բանալին:

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Ավելացրեք պահեստը Nginx-ի կայուն տարբերակի համար:

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Թարմացրեք համակարգի պահեստները:

$ sudo apt update

Տեղադրեք Nginx-ը:

$ sudo apt install nginx

Ստուգեք տեղադրումը:

$ nginx -v
nginx version: nginx/1.24.0

Գործարկեք Nginx սերվերը:

$ sudo systemctl start nginx

Քայլ 8 - Տեղադրեք SSL-ը

Առաջին քայլը Let's Encrypt SSL վկայականի տեղադրումն է: SSL վկայագիր ստեղծելու համար մենք պետք է տեղադրենք Certbot-ը: Կարող եք կա՛մ տեղադրել Certbot-ը՝ օգտագործելով Ubuntu-ի պահոցը, կա՛մ ձեռք բերել վերջին տարբերակը՝ օգտագործելով Snapd գործիքը: Մենք կօգտագործենք Snapd տարբերակը:

Ubuntu 22.04-ը գալիս է լռելյայն տեղադրված Snapd-ով: Գործարկեք հետևյալ հրամանները՝ համոզվելու համար, որ Snapd-ի ձեր տարբերակը արդիական է:

$ sudo snap install core && sudo snap refresh core

Տեղադրեք Certbot-ը:

$ sudo snap install --classic certbot

Օգտագործեք հետևյալ հրամանը՝ համոզվելու համար, որ Certbot հրամանը կարող է գործարկվել՝ ստեղծելով խորհրդանշական հղում դեպի /usr/bin գրացուցակը:

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Ստեղծեք SSL վկայագիր kibana.example.com տիրույթի համար:

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d kibana.example.com

Վերը նշված հրամանը վկայական կներբեռնի ձեր սերվերի /etc/letsencrypt/live/kibana.example.com գրացուցակում:

Ստեղծեք Diffie-Hellman խումբ վկայագիր:

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Ստուգեք Certbot-ի նորացման ժամանակացույցի ծառայությունը:

$ sudo systemctl list-timers

Դուք կգտնեք snap.certbot.renew.service որպես սպասարկվող ծառայություններից մեկը:

NEXT                        LEFT          LAST                        PASSED         UNIT                     ACTIVATES
------------------------------------------------------------------------------------------------------------------------------------
Mon 2023-05-06 13:37:57 UTC 3h 45min left Mon 2023-05-01 07:20:42 UTC 2h 31min ago   ua-timer.timer           ua-timer.service
Mon 2023-05-06 14:39:29 UTC 4h 47min left Sat 2023-02-04 16:04:18 UTC 2 months ago   motd-news.timer          motd-news.service
Mon 2023-05-06 15:53:00 UTC 6h left       n/a                         n/a            snap.certbot.renew.timer snap.certbot.renew.service

Կատարեք գործընթացի չոր գործարկում՝ ստուգելու, թե արդյոք SSL-ի նորացումը լավ է աշխատում:

$ sudo certbot renew --dry-run

Եթե սխալներ չեք տեսնում, ամեն ինչ պատրաստ է: Ձեր վկայականը ինքնաբերաբար կերկարաձգվի:

Քայլ 9 - Կարգավորեք Nginx-ը

Ստեղծեք և բացեք Nginx կազմաձևման ֆայլը Kibana-ի համար:

$ sudo nano /etc/nginx/conf.d/kibana.conf

Դրա մեջ տեղադրեք հետևյալ կոդը. Փոխարինեք IP հասցեն ձեր Elasticsearch սերվերի մասնավոր IP հասցեով:

server {
        listen 80; listen [::]:80;
        server_name kibana.example.com;
        return 301 https://$host$request_uri;
}

server {
        server_name kibana.example.com;
        charset utf-8;

        listen 443 ssl http2;
        listen [::]:443 ssl http2;

        access_log /var/log/nginx/kibana.access.log;
        error_log /var/log/nginx/kibana.error.log;

        ssl_certificate /etc/letsencrypt/live/kibana.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/kibana.example.com/privkey.pem;
        ssl_trusted_certificate /etc/letsencrypt/live/kibana.example.com/chain.pem;
        ssl_session_timeout 1d;
        ssl_session_cache shared:MozSSL:10m;
        ssl_session_tickets off;

        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;

		resolver 8.8.8.8;

        ssl_stapling on;
        ssl_stapling_verify on;
        ssl_dhparam /etc/ssl/certs/dhparam.pem;

        location / {
                proxy_pass http://localhost:5601;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;
        }
}

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ պահանջվում է:

Բացեք ֆայլը /etc/nginx/nginx.conf խմբագրման համար:

$ sudo nano /etc/nginx/nginx.conf

Ավելացրեք հետևյալ տողը include /etc/nginx/conf.d/*.conf; տողից առաջ:

server_names_hash_bucket_size  64;

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ պահանջվում է:

Ստուգեք կազմաձևը:

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Վերագործարկեք Nginx ծառայությունը:

$ sudo systemctl restart nginx

Անհրաժեշտ է ևս մեկ քայլ. Բացեք Docker compose ֆայլը խմբագրման համար:

$ nano ~/docker-compose.yml

Կպցրեք SERVER_PUBLICBASEURL=https://kibana.example.com տողը Kibana ծառայության շրջակա միջավայրի բաժնի տակ հետևյալ կերպ:

    environment: # Defined host configuration
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
      - SERVER_PUBLICBASEURL=https://kibana.example.com

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ ձեզ հուշում են ավարտելուց հետո:

Դադարեցրեք և հանեք տարաները:

$ docker compose down --remove-orphans

Նորից սկսեք տարաները թարմացված կազմաձևով:

$ docker compose up -d

Ձեր Kibana վահանակը պետք է հասանելի լինի https://kibana.example.com URL-ի միջոցով ցանկացած վայրից, որտեղ ցանկանում եք:

Քայլ 10 - Docker կոնտեյների գործարկում Fluentd Log Driver-ով

Այժմ մենք գործարկելու ենք Docker կոնտեյներ Fluentd log drive-ով` ավտոմատ կերպով ուղարկելով տեղեկամատյանները բուրգ: Մենք փորձարկելու ենք Nginx կոնտեյների միջոցով:

Քաշեք Nginx պատկերը Docker Hub ռեեստրից: Մենք օգտագործում ենք alpine տարբերակը, քանի որ այն պատկերի ամենափոքր տարբերակն է:

$ docker pull nginx:alpine

Գործարկեք հետևյալ հրամանը՝ Nginx կոնտեյները ստեղծելու և գործարկելու համար: Մենք դրել ենք մատյան դրայվերը Fluentd, իսկ նավահանգիստը՝ 8080, քանի որ լռելյայն 80 նավահանգիստն արդեն օգտագործվում է Nginx սերվերի կողմից պրոքսի ռեժիմում։

$ docker run --name nginx-fluentd-test -d --log-driver=fluentd -p 8080:80 nginx:alpine

Ստուգեք կոնտեյների կարգավիճակը:

$ docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED          STATUS          PORTS                                                                                                    NAMES
038c43e4e1a3   nginx:alpine          "/docker-entrypoint.…"   12 seconds ago   Up 11 seconds   0.0.0.0:8080->80/tcp, :::8080->80/tcp                                                                    nginx-fluentd-test
a94ca706bd0c   efk-fluentd           "tini -- /bin/entryp…"   8 hours ago      Up 8 hours      5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp   efk-fluentd-1
0cf04a446425   kibana:8.7.1          "/bin/tini -- /usr/l…"   8 hours ago      Up 8 hours      0.0.0.0:5601->5601/tcp, :::5601->5601/tcp                                                                efk-kibana-1
7c7ad8f9b123   elasticsearch:8.7.1   "/bin/tini -- /usr/l…"   8 hours ago      Up 8 hours      9200/tcp, 9300/tcp                                                                                       efk-elasticsearch-1

Գործարկեք հետևյալ հրամանը՝ Nginx կոնտեյներ մուտք գործելու և մուտքի տեղեկամատյաններ ստեղծելու համար:

$ curl localhost:8080
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Որպես այլընտրանք, դուք կարող եք բացել http://:8080 URL-ը ձեր բրաուզերում և կստանաք հետևյալ էջը:

Բացեք Kibana-ի վահանակը և սեղմեք Բացահայտեք հղմանը ձախ կողագոտու ցանկում: Սեղմեք + նշանը վերևի ընտրացանկում՝ Ավելացնել զտիչ բացվող պատուհանը բացելու համար:

Բացվող ցանկից ընտրեք container_name դաշտը, որպես օպերատոր is և որպես դաշտի արժեք լրացրեք կոնտեյների անունը ( nginx-fluentd-test): .

Սեղմեք Ավելացնել զտիչ կոճակը՝ Nginx կոնտեյների տվյալները պատկերացնելու համար:

Եզրակացություն

Սա ավարտում է մեր ձեռնարկը Ubuntu 22.04 մեքենայի վրա Elasticsearch, Fluentd և Kibana (EFK) լոգերի փաթեթի տեղադրման վերաբերյալ: Եթե ունեք հարցեր, տեղադրեք դրանք ստորև ներկայացված մեկնաբանություններում: