ELK Stack : Shipping metrics data with metricbeat

     Halo semua, pada kesempatan kali ini kami akan share tutorial tentang mengirimkan data metrics dari sebuah server menggunakan metricbeat. Metricbeat adalah beat yang sangat populer yang mengumpulkan dan melaporkan berbagai metrik tingkat sistem untuk berbagai sistem dan platform. Metricbeat juga mendukung modul internal untuk mengumpulkan statistik dari platform tertentu. Anda dapat mengonfigurasi frekuensi Metricbeat mengumpulkan metrik dan metrik spesifik apa yang akan dikumpulkan menggunakan modul dan sub-pengaturan ini yang disebut metricsets. Metric mewakili pengukuran raw penggunaan sumber daya atau perilaku yang dapat diamati dan dikumpulkan di seluruh sistem Anda. Ini mungkin ringkasan penggunaan tingkat rendah yang disediakan oleh sistem operasi, atau dapat berupa jenis data tingkat yang lebih tinggi yang terkait dengan fungsionalitas atau pekerjaan tertentu dari suatu komponen, seperti permintaan yang disajikan per detik atau keanggotaan dalam kumpulan server web. Beberapa metrik disajikan dalam kaitannya dengan kapasitas total, sementara metrik lainnya direpresentasikan sebagai tingkat yang menunjukkan "kesibukan" suatu komponen. Kurang lebih itu penjelasan yang dapat kami ambil, lebih lengkap bisa baca di sini. Untuk langkah-langkahnya sebagai berikut :

1.  Installasi metricbeat 

```bash
$ sudo wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key 
add -
$ sudo echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo 
tee -a /etc/apt/sources.list.d/elastic-7.x.list
$ sudo apt-get update && sudo apt-get install metricbeat
```

2. Konfigurasi metricbeat

```bash
$ sudo cp /etc/metricbeat/metricbeat.yml /etc/metricbeat/metricbeat.yml.origin
$ sudo vi /etc/metricbeat/metricbeat.yml

# berikut adalah contoh untuk send metric dari system dan apache
```
```yaml
metricbeat.modules:
- module: system
  metricsets: ["cpu","memory","network"]
  enabled: true
  period: 15s
  processes: ['.*']
- module: apache
  metricsets: ["status"]
  enabled: true
  period: 5s
  hosts: ["http://10.20.21.23"]
```
```bash
# check apakah index sudah berjalan
$ sudo metricbeat modules enable system
```

3. Atur output dari metricbeat

```bash
# dikirim ke elasticsearch langsung
output.elasticsearch:
  hosts: ["10.20.21.254:9200"]

# dikirim ke logstash
output.logstash:
  hosts: ["10.20.21.254:5044"]
  
# dikirim ke kafka
output.kafka:
  hosts: ["ip_server_kafka:9092"]
  topic: "topicname"
  
# dikirim ke redis
output.redis:
  hosts: ["ip_redis_server:6379"]
  index: "redis.index.for.logstash"
  key: "metricbeat.to.redis"
```

4. Jalankan metricbeat

```bash
# check config untuk verifikasi
$ sudo metricbeat -c /etc/metricbeat/metricbeat.yml test config
$ sudo service metricbeat start
```

5. Verifikasi

```bash
$ curl -XGET '10.20.21.254:9200/_cat/indices?v&pretty'
```

Yaps, sampai jumpa di turorial berikutnya!

Read More

ELK Stack : Shipping logs with filebeat

 

Halo semua, pada kesempatan kali ini kami akan share tentang bagaimana client mengirimkan log ke ELK server, dengan menggunakan filebeat yang merupakan salah satu shipper yang ringan dan banyak digunakan. Untuk environment dari lab kali ini masih sama dengan environmet pada post berikut. Karen bisa dibilang, pada lab ini adalah lanjutannya. Baik, Berikut adalah langkah-langkahnya :

1. Instalasi Filebeat di Ubuntu 18.04

```bash
$ sudo apt -y update

$ sudo wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
$ sudo apt -y install apt-transport-https
$ sudo echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee -a /etc/apt/sources.list.d/elastic-7.x.list
$ sudo apt -y update && apt -y install filebeat

$ sudo systemctl enable filebeat
$ sudo systemctl status filebeat
```

2. Konfigurasi pada Logstash

```bash
# pada ELK server

$ sudo vi /etc/logstash/conf.d/filter-syslog.conf

```
```json
filter {
  if [fields][log_name] == "syslog" {
    mutate {
      add_tag => [ "syslog" ]
    }
  }
}
```

```bash
$ sudo systemctl restart logstash
$ sudo systemctl status logstash
```

3. Konfigurasi Filebeat

```bash
$ sudo mv /etc/filebeat/filebeat.yml /etc/filebeat/filebeat.yml.original
$ sudo vi /etc/filebeat/filebeat.yml
```
```yaml
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/syslog
  fields:
    log_name: syslog

output.logstash:
  hosts: ["10.20.21.254:5044"]
```

4. Aktifkan layanan filebeat

```bash
$ sudo systemctl restart filebeat
$ sudo systemctl status filebeat
```

5. Verifikasi

```bash
$ curl http://10.20.21.254:9200/_cat/indices?v
```

6. Atur dashboard

```bash
# Klik Menu Management > Elasticsearch > Index Management
# Membuat Index Pattern
# Klik Menu Management -> Kibana -> Index Patterns
# Klik Create Index Pattern
# Index Pattern Name: syslog_*
# Klik Next Step
# Time Filter field name: @timestamp
# Klik Create Index Pattern
```

Yaps, sampai jumpa di tutorial berikutnya! 

Read More

ELK Stack : Elasticsearch, Logstash and Kibana Installation

 

Halo semua, pada kesempatan kali ini kami akan mulai untuk tutorial dari ELK stack ini. Pada sesi kali ini akan dimulai dengan Installasi dari ELK stack, bagi yang belum paham komponen dan penjelasan tentang ELK, Bisa tengok di postingan berikut. Disana akan menjadi landasan sebelum kita melakukan praktek, agar paham apa saja komponen dan fungsinya. Oke, Sebelum masuk ke langkah-langkah percobaan, kita akan tunjukan environment dari lab kita nantinya.

 - ELK stack Server : 

|     Hostname   | pod0-elk |
| ----------- | ----------- |
| IP Adress   | 10.20.21.254|
| OS | Ubuntu 18.04 |
| Ram | 4GB |

- Client Server/ Beat

|     Hostname   | pod1-elk |
| ----------- | ----------- |
| IP Adress   | 10.20.21.253|
| OS | Ubuntu 18.04 |
| Ram | 512MB |

Pada lab ini, kami menggunaka Ubuntu 18.04, pada semua node/podnya. Tapi dalam penerapannya baik client/server dapat menggunakan sistem operasi lainya. Lengkapnya untuk support dari ELK dapat di check di sini. Jika environment sudah siap, mari kita lanjut ke langkah-langkah percobaan berikut :

Install ElasticSearch

1.  Update repository

```bash
$ sudo apt -y update
```

2.  Install dependensi

```bash
$ sudo apt -y install openjdk-8-jdk
$ java -version
```

3.  Install ElasticSeach

```bash
$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
$ sudo apt -y install apt-transport-https
$ echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee -a /etc/apt/sources.list.d/elastic-7.x.list
$ sudo apt -y update && apt -y install elasticsearch
```

4.  Konfigurasi ElasticSearch

```bash
$ cp /etc/elasticsearch/elasticsearch.yml /etc/elasticsearch/elasticsearch.yml.original
$ vi /etc/elasticsearch/elasticsearch.yml
```
```yaml
# cari bagian berikut dan uncoment atau hilangkan pagar didepanya
# lalu ganti localhost dengan ipaddress dari server
network.host: 10.20.21.254
network.port: 9200
# tambahkan juga, karena jika kita runing dengan host berupa IP, 
# dianggap production jadi perlu kita set tipe discover
discovery.type: single-node
```

5.  jalankan ElasticSearch

```bash
$ sudo systemctl daemon-reload
$ sudo systemctl enable elasticsearch
$ sudo systemctl start elasticsearch
$ sudo systemctl status elasticsearch
```

6.  Verifikasi

```bash
$ netstat -tupln
$ curl -XGET 'localhost:9200/?pretty'
$ curl -XGET '10.20.21.254:9200/?pretty'
```

Install LogStash

1.  Installasi Logstash

```bash
$ sudo apt -y install logstash
```

2.  Konfigurasi Logstash

```bash
$ sudo vi /etc/logstash/conf.d/input-filebeat.conf
```
```bash
input {
  beats {
    port => 5044
  }
}
```

3.  Membuat Output dari Logstash

```bash
$ sudo vi /etc/logstash/conf.d/output-elasticsearch.conf
```
```bash
output {
  elasticsearch {
    hosts => ["10.20.21.254:9200"]
    manage_template => false
    index => "%{[fields][log_name]}_%{[agent][hostname]}_%{+YYYY.MM}"
  }
}
```

4.  Jalankan Logstash

```bash
$ sudo systemctl enable logstash
$ sudo systemctl start logstash
$ sudo systemctl status logstash
$ netstat -tupln
```

Install Kibana

1.  Installasi Kibana

```bash
$ sudo apt -y install kibana
```

2.  Konfigurasi dan integrasi dengan ElasticSearch

```bash
$ sudo cp /etc/kibana/kibana.yml /etc/kibana/kibana.yml.original
$ sudo vi /etc/kibana/kibana.yml
```
```bash
server.port: 5601
server.host: "10.20.21.254"
elasticsearch.hosts: ["http://10.20.21.254:9200"]
```

3.  Jalankan Kibana

```bash
$ sudo systemctl enable kibana
$ sudo systemctl start kibana
$ sudo systemctl status kibana
```

4.  Installasi nginx dan konfigurasi

```bash
$ sudo apt -y install nginx apache2-utils
$ sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/default.original
$ sudo vi /etc/nginx/sites-available/default
```
```bash
#hapus semua dan ganti seperti berikut
server {
    listen 80;

    server_name _;

    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/htpasswd.kibana;

    location / {
        proxy_pass http://localhost:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}
```

5.  Buat user dan jalankan Nginx

```bash
# ganti [username] dengan username yang akan kita gunakan
$ sudo htpasswd -c /etc/nginx/htpasswd.kibana [username]
$ sudo systemctl enable nginx
$ sudo systemctl restart nginx
$ sudo systemctl status nginx
$ netstat -tupln
```

6. Verifikasi

Coba untuk akses via browser

Yaps, diatas adalah installasi ELK stack, untuk install beat akan dibahas pada tutorial berikutnya, sampai jumpa!

Read More

ELK Stack : What is ELK? (ElasticSearch , Logstash , Kibana)

 

    Halo semua, pada kesempatan kali ini, kami akan share tentang salah satu tools monitoring yang banyak digunakan, yaitu ELK Stack. Stack ini menjadi kesatuan karena biasa digunakan untuk monitoring menjadi satu paket, walaupun pada aslinya berbebeda aplikasi. Dan kali ini kami akan share beberapa hal tentang hal tersebut. Elasticsearch, Logstash dan Kibana adalah tool yang berguna untuk mengumpulkan log dan juga menvisualisasi,Elasticsearch berguna untuk menyimpan semua log yang berasal dari server, Logstash merupakan sebuah perangkat lunak open source untuk mengumpulkan dan memparsing log dan juga membuat index untuk log, kemudian disimpan pada elasticsearch. Kibana adalah web interface yang berguna untuk menampilkan log baik dalam bentuk grafik maupun visualisasi lainnya. untuk file agent di perlukan filebeat yang berguna untuk mengirim log dari setiap server kepada logstash. 

    Kenapa perlu untuk memusatkan log ?. Karena, Log yang tersentralisasi sangat berguna jika suatu saat seorang DevOps akan melakukan identifikasi masalah pada server atau aplikasi. Hal tersebut membuat mereka mampu mencari histori data atau log, intinya memudahkan dalam proses monitoring dan juga troubleshooting. 

Dan berikut adalah komponen dari ELK Stack :

-  Elasticsearch : Bertugas untuk menyimpan semua log.

-  Logstash        : Bertugas untuk memproses log dan membuat index log.
-  Kibana       : Sebagai Web interface untuk mencari dan memvisualisasikan log baik dalam grafik yang di inginkan

Sedangkan untuk yang berikut adalah opsional :
- Filebeat          : Berfungsi mengirim log ke logstash. Berfungsi sebagai shipping agent untuk log. Menggunakan lumberjack networking protocol untuk berkomunikasi dengan logstash. Filebeat akan dipasang di server yang mempunyai log (yang akan diproses).

Untuk filebeat ini kenapa bersifat opsional, karena dapat digantikan dengan agent lain, karena si filebeat ini bertugas mengirimkan log dari sisi client  yang akan dimonitor. Untuk penggambarannya dapat dilihat seperti diagram berikut :

Untuk check beberapa agent yang bisa dipakai atau recomended  bisa check di sini, Untuk melihat beberapa daftar beatsnya . [source]

Yaps, sampai jumpa di postingan berikutnya!

Read More

Docker : Deploy python app with Docker compose

 Halo semua, pada kesempatan kali ini. Kami akan share tutorial medeploy aplikasi python dengan menggunakan docker compose, kalau kita sebelumnya deploy wordpress dengan docker compose, kali ini kita coba deploy aplikasi buatan kita yang menggunakan bahasa pemogram python pada contoh kali ini, untuk langkah-langkahnya sebagai berikut :

1. Buat folder proyek

```bash
$ mkdir my_app; cd my_app
```

2. Buat file aplikasi

```bash
$ vim app.py
```

```python
import time

import redis
from flask import Flask


app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", debug=True)
```

3. Buat file requirement

```bash
$ vim requirements.txt
```
```plaintext
flask
redis
```

4. Buat Dockerfile untuk image

```bash
$ vim Dockerfile
```
```bash
FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
```

5. Buat docker compose untuk konfigurasi

```bash
$ vim docker-compose.yml
```
```yaml
version: '3.2'
services:
  web:
    build: .
    ports:
     - "5000:5000"
    volumes:
     - .:/code
  redis:
    image: "redis:alpine"
```

6. Jalankan docker compose

```bash
$ sudo docker-compose up -d
```

7. verifikasi

```bash
$ curl http://localhost:5000

# check docker-compose aktif
$ sudo docker-compose ps
# check environment aplikasi
$ sudo docker-compose run web env
```

Kalau kita check via browser

8. Hapus aplikasi

```bash
$ sudo docker-compose down --volumes
```

Yaps, sampai jumpa di tutorial berikutnya !

Read More

Docker : Deploy Wordpress app with Compose

 Halo semua, pada kesempatan kali ini kami akan berbagi contoh penerapan dari docker compose dalam membangun sebuah aplikasi, pada contoh kali ini kami akan membangun aplikasi wordpress dengan metode docker compose. Berikut adalah langkah-langkah yang dilakukan :

1. Buat Folder proyek

```bash
$ mkdir /my_wordpress ;cd /my_wordpress
```

2. Buat file konfigurasi docker compose

```bash
$ vim docker-compose.yml
```
```yaml
version: '3.2'

services:
   db:
     image: mysql:5.7
     volumes:
       - dbdata:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: [username]
       MYSQL_PASSWORD: [password]

   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     ports:
       - "8000:80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: [username]
       WORDPRESS_DB_PASSWORD: [password]
volumes:
    dbdata:
```
```bash
# catatan untuk [username] dan [password] bisa dirubah dengan kebutuhan kita(bebas)
# kalau default seperti [username] dan [password] akan error saat docker-compose di up
```

3. jalankan docker compose

```bash
$ sudo docker-compose up -d
# jika terjadi error saat pull image, biasanya masalah authentikasi silahkan login ke docker hub dengan cara berikut
$ docker login
# masukan username(docker id) dan password
```

4. verifikasi

```bash
$ sudo docker container ls
```

5. hapus aplikasi

```bash
$ sudo docker-compose down --volumes
```

Yaps, sekian dulu. sampai jumpa di tutorial berikutnya!

Read More

Docker : Docker compose installation

 

Halo semua, pada kesempatan kali ini kami akan berbagi tutorial tentang Docker compose.  Sebelum beranjak ke langkah berikutnya, kita akan review sedikit apa itu docker compose dan bedanya dengan docker biasa. Compose adalah tools untuk mendefinisikan dan menjalankan aplikasi Docker multi-container. Dengan hanya menulis di file konfigurasi,  file digunakan untuk mengonfigurasi layanan aplikasi kita yang berjalan di docker. Kemudian, dengan menggunakan satu perintah, kita dapat membuat dan memulai semua layanan dari konfigurasi tadi. Kurang lebih seperti itu jika kita mengarah kepada pengertian yang ada pada halaman resminya. Jadi, intinya sesuai dengan logo dari docker compose yaitu gurita yang memegangf banyak container , kurang lebih seperti itu. Dengan docker compose  kita dapat menjalankan  banyak container yang saling terhubung hanya dengan menuliskannya pada file konfigurasi dan menjalankannya dengan sekali perintah. Dan jika ada perubahan kita dapat mengubahnya langsung pada file konfigurasi lalu menjalankan ulang(restart) docker composenya. Dan berikut adalah cara untuk installasasinya, untuk contoh penerapannya, ada di tutorial berikut.

1. Mengunduh docker compose

```bash
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```

2. Mengatur permission dari docker compose

```bash
$ sudo chmod +x /usr/local/bin/docker-compose
```

3. Verifikasi 

```bash
$ sudo docker-compose --version
```

Yaps, sekian dulu. sampai jumpa di tutorial berikutnya!

Read More

Docker : Secrets

Halo semua, pada kesempatan kali ini kami akan berbagi sedikit tentang secret pada docker. Diantara manfaat dari secret ini adalah untuk menyimpan informasi yang sifatnya sensitif, seperti password, token, dan sebagainya. Kurang lebih itu adalah beberapa manfaat implentasi dari secret. Dan berikut adalah langkah-langkah untuk labnya :

1. Membuat secret

```bash
$ printf "This is a secret" | sudo docker secret create my_secret -
```

2. Membuat service redis dan mengizinkan akses terhadap secret yang sudah dibuat

```bash
$ sudo docker service  create --name redis --secret my_secret redis:alpine
```

3. Verifikasi service redis

```bash
$ sudo docker service ps redis
```

4. Baca content di dalam container

```bash
$ sudo docker ps --filter name=redis -q
$ sudo docker container exec $(docker ps --filter name=redis -q) ls -l /run/secrets
$ sudo docker container exec $(docker ps --filter name=redis -q) cat /run/secrets/my_secret
```

5. Verifikasi secret tidak ada di image hasil commit container

```bash
$ sudo docker commit $(docker ps --filter name=redis -q) committed_redis
$ sudo docker run --rm -it committed_redis cat /run/secrets/my_secret
```

6. Menghapus akses service redis dari secret

```bash
$ sudo docker service update --secret-rm my_secret redis
```

7. Verifikasi service redis sudah tidak ada akses

```bash
$ sudo docker container exec $(docker ps --filter name=redis -q) ls -l /run/secrets
```

8. Hapus secret dan service

```bash
$ sudo docker service rm redis
$ sudo docker secret rm my_secret

# sebagai catatan : untuk menghapus secret perlu dipastikan tidak ada service yang akses terhadap secret tersebut
# untuk menghapus akses bisa dilihat di langkah nomor 6
```

Yaps, sekian dulu, sampai jumpa di tutorial berikutnya!

 

Read More

Docker : Overlay Network Without Swarm

 

Halo semua, pada kesempatan kali ini kami akan berbagi tutorial tentang overlay network tanpa docker swarm. Seperti kita tahu bahwa swarm ini adalah orchestration tool, yang memungkinkan kita untuk deploy container di multihost. Jadi memang satu tipe dengan kubernetes. Tapi pada kesempatan kali ini kita tidak akan menggunakan swarm, dalam menggunakan overlay network. Pertama mari kita samakan persepsi dulu, overlay network pada pembahasan ini mengacu pada menghubungkan antar container yang berada pada host/node yang berbeda satu sama lain. Untuk environment lab kali ini kita akan menggunakan lebih dari satu host/node, mengaju pada lab berikut, Dengan tambahan 1 host/node lagi, jadi detailnya sebagai berikut :

    - pod0-docker ( IP : 10.20.21.254 )

    - pod1-docker ( IP : 10.20.21.253 )

    - pod2-docker ( IP : 10.20.21.252 )

Dengan masing-masing host/node sudah terinstall docker, berikut adalah langkah-langkahnya :

1. Di pod0-docker, jalankan key-value store consul

```bash
$ sudo docker run -d -p 8500:8500 -h consul --name consul progrium/consul -server -bootstrap
```

2. Di pod1-docker dan pod2-docker, matikan service docker dan jalankan docker dari CLI

```bash
$ sudo systemctl stop docker
$ sudo systemctl status docker
$ sudo /usr/bin/docker daemon -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --cluster-advertise ens3:2375 --cluster-store consul://10.20.21.254:8500 &
```

3. Di pod1-docker atau pod2-docker, buat overlay network

```bash
# pad contoh ini saya buat di pod2-docker
$ sudo docker network create -d overlay --subnet=10.0.0.0/24 my-overlay
$ sudo docker network ls
```

4. Di pod1-docker, buat container alpine1 terhubung ke network my-overlay

```bash
$ sudo docker run -dit --name alpine1 --network my-overlay alpine ash
```

5. Di pod2-docker, buat container alpine2 terhubung ke network my-overlay

```bash
$ sudo docker run -dit --name alpine2 --network my-overlay alpine ash
```

6. Di pod2-docker, tampilkan detil network my-overlay

```bash
$ sudo docker network inspect my-overlay
```

7. Di pod2-docker, masuk ke container alpine2 dan uji ping ke alamat ip dan nama container alpine1 (sukses)

```bash
$ sudo docker attach alpine2
$ ping -c 3 10.0.0.x
$ ping -c 3 alpine1

# x pada IP di atas, sesuai dengan ip pada alpine1
```

Sampai di sini jika berhasil(sukses), berarti kita sudah mencapai tujuan untuk menggunakan overlay network tanpa swarm. Dan langkah berikut digunakan Membersihkan hasil lab dan mengembalikan ke kondisi awal.

8. Di pod1-docker, hapus container alpine1, matikan command docker dan nyalakan service docker

```bash
$ sudo docker container rm -f alpine1
$ sudo ps -aux | grep docker | head -1
$ sudo kill [PID COMMAND DOCKER]
$ sudo systemctl start docker
$ sudo systemctl status docker
```

9. Di pod2-docker, hapus container alpine2, hapus network my-overlay, matikan command docker dan nyalakan service docker

```bash
$ sudo docker container rm -f alpine2
$ sudo docker network rm my-overlay
$ sudo ps -aux | grep docker | head -1
$ sudo kill [PID COMMAND DOCKER]
$ sudo systemctl start docker
$ sudo systemctl status docker
```

10. Di pod0-docker, hapus key-value store consul

```bash
$ sudo docker rm -f consul
```

Yaps, sekian dan sampai jumpa di tutorial berikutnya!

Read More

Docker : Host Network

 Halo semua, pada kesempatan kali ini kami akan berbagai tutorial tentang host network, masih berhubungan dengan networking pada docker, bagi yang belum baca bisa mampir di mari. Jadi intinya host network ini adalah kita menjalankan container pada jaringan di level host. Ini berarti ketika kita menjalankan container , container tersebut dapat kita akses dengan menggunakan alamat IP dari host/ server yang menjalankan docker. Pada contoh berikut kita akan coba menjalankan container dengan aplikasi web server, yaitu nginx, lalu kita dapat mengaksesnya dengan menggunakan ip address dari host. Berikut adalah langkah-langkahnya:

1. Menjalankan container

```bash
$ sudo docker run --rm -itd --network host --name my_nginx nginx
```

2. Verifikasi via browser atau cli

```bash
$ curl http://localhost
```

3. Verifikasi alamat IP dan bound port 80

```bash
$ ip add
$ sudo netstat -tulpn | grep :80
```

4. Hentikan container

```bash
$ sudo docker container stop my_nginx
```

Yaps, sekian dulu untuk kesempatan kali ini, sampai jumpa di tutorial berikutnya!

Read More

Docker : User-Defined Bridge Network

 

Hallo semua, pada kesempatan kali ini kami akan share tentang bagaimana caranya kita membuat network pada docker. Sebelum belajar tutorial ini, baiknya untuk membaca post berikut. Harapanya agar dapat memahami terlebih dahulu tentang networking pada docker. Berikut adalah langkah-langkahnya :

1. Membuat bridge network dengan nama mynetwork

```bash
$ sudo docker network create --driver bridge mynetwork
```

2. Menampilkan daftar network 

```bash
$ sudo docker network ls

# pastikan ada network dengan nama mynetwork
```

3. Melihat deskripsi dari network mynetwork

```bash
$ sudo docker network inspect mynetwork
```

4. Membuat 3 container 

```bash
# networking pada network sebagai berikut :
# alpine1 terhubung ke default bridge
# alpine2 terhubung ke mynetwork
# alpine3 terhubung ke 2 network

$ sudo docker run -dit --name alpine1 alpine ash
$ sudo docker run -dit --name alpine2 --network mynetwork alpine ash
$ sudo docker run -dit --name alpine3 alpine ash
$ sudo docker network connect mynetwork alpine3
$ sudo docker container ls

```

5. Tampilkan detail network bridge dan mynetwork

```bash
$ sudo docker network inspect bridge
$ sudo docker network inspect mynetwork
```

6. Masuk ke container dan test koneksi antar container

```bash
$ masuk ke alpine3 dan test
$ sudo docker attach alpine3

# ping ke IP alpine1
$ ping -c 3 172.17.YYY.YYY
$ ping -c 3 alpine1
$ ping -c 3 alpine2

# masuk ke alpine2
# test ping ke IP alpine1
$ sudo docker attach alpine2
$ ping -c 3 172.17.YYY.YYY
$ ping -c 3 8.8.8.8
```

7. Menghapus network dan container

```bash
# hapus hasil lab
$ sudo docker container rm -f alpine1 alpine2 alpine3
$ sudo docker network rm mynetwork
```

Yaps, sampai di sini dulu, sampai ketemu di tutorial berikutnya!

Read More