<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by ahmad asrori on Medium]]></title>
        <description><![CDATA[Stories by ahmad asrori on Medium]]></description>
        <link>https://medium.com/@ahmad-asrori?source=rss-4cee03937f4e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*W65shX2SKnQYX_SP.</url>
            <title>Stories by ahmad asrori on Medium</title>
            <link>https://medium.com/@ahmad-asrori?source=rss-4cee03937f4e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 02:03:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ahmad-asrori/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[My Experience in Developing Open Source Software on Awan IO on IBM Power System]]></title>
            <link>https://ahmad-asrori.medium.com/my-experience-in-developing-open-source-software-on-awan-io-on-ibm-power-system-44a4bbe5922f?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/44a4bbe5922f</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Wed, 21 Jun 2023 08:23:58 GMT</pubDate>
            <atom:updated>2023-06-21T08:23:58.223Z</atom:updated>
            <content:encoded><![CDATA[<h3>Forewords</h3><p>Open-source technology has significantly influenced tech companies. Besides being the preferred tool for programmers, open source technology is also the global default choice for software architecture. Consequently, proficiency in working with open-source software has become important in the software industry. On the other hand, IBM Power Systems empowers organizations by providing great resilience, scalability, and accelerated performance.</p><p>The IBM Power platform can also leveraging open-source technologies to enabling the seamless operation of these workloads in a hybrid cloud environment, it is also supported by consistent tools, processes, and skills. This article will explain the author’s experience in developing open source software on Awan IO on IBM Power System</p><h3>Open Source Technology</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/1*AAlANgrFC0EXvudJSoaOvA.png" /></figure><p>Open-source technology commonly refers to software where the code is intended to be accessible to the public. It allows anyone to view, modify, and distribute the code according to their preferences. While the source code is freely available, the executable software may require a subscription or fee. Open source is more than anything, it has a significant impact on the software development community.</p><h4><strong>What are the Benefits of Incorporating Open Source Technology?</strong></h4><p>The advantages of open-source technology are widely acknowledged and extensive. However, what aspects of open-source software are enterprises primarily focused on? There are top 5 pros of open-source technology, especially for businesses and enterprises :</p><p>1. High-Quality Development</p><p>Commitment to make excellent products is the basic principle. This commitment can be seen through the inclusion of peer review and awareness from the community. Additionally, businesses can gain cost advantages by leveraging open source solutions, eliminating the need to start coding from scratch and building on existing resources instead.</p><p>2. Secured</p><p>An example of fully open source software is the Linux operating system. It should be noted that open source software provides a higher level of security than is generally assumed. the level of security is related to the collaborative nature of its development and review of its source code.</p><p>3. More Affordable</p><p>Cost savings are often cited as the most prominent benefit of this technology. Open source programs usually do not charge a business a usage fee. It also eliminates the need to manage license renewals. open source applications bring significant cost-saving benefits to enterprises. Despite the evolving software landscape and some communities, open source applications remain freely accessible. This makes it very useful for businesses to save on software costs.</p><p>4. Highly Customized and Flexible</p><p>Open source software can be identified in freedom and flexibility. As a result, the wide availability of open source projects in public repositories makes their direct utilization possible. By removing constraints related to procurement and licensing, open source software facilitates a learning process for developers, which proves to be beneficial for businesses and enterprises.</p><p>5. Big Community</p><p>When individuals pay full attention to products and not just for the money, they are motivated to contribute and share their best ideas. It is also the driving force behind developing innovative and disruptive features within the open-source community. On the other hand, all organizations must prioritize the modernization and digitization of their resources. This involves implementing an active and adaptable approach to the utilization and administration of this technology.</p><h3><strong>IBM Power Systems</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/374/1*V6_5vqQmSZJ6E8maqTH7DA.jpeg" /><figcaption>IBM Power Server</figcaption></figure><p>IBM Power Systems is a range of enterprise servers that bring about a transformative impact on your organization. These servers have been known for their great resilience, scalability, and accelerated performance. Thus, this technology handles mission-critical workloads and cutting-edge AI and edge solutions. Additionally, IBM Power System has been recognized as the backbone behind clients business operations. Building on this foundation and the recent survey, IBM remains committed to assisting customers in modernizing their infrastructure with the IBM Power System.</p><p>application modernization is the process of taking existing legacy application and modernizing platform infrastructure, internal architecture, and/or feature. One of the strategies for app modernization is to invest in the right tools &amp; technologies early in the process to support all app modernization approaches. The benefits of application modernization are increasing the speed at which new features are delivered, exposing existing application functionality to be consumed via APIs by other services, and re-platforming applications from on-premises to the cloud for the purposes of application scale and performance as well as long-term data center and IT strategies.</p><h4><strong>Awan IO on IBM Power System</strong></h4><p>Awan IO is a Platform as a Service (PaaS) that supports the needs of its clients for hosting applications and data. Awan IO can be deployed in any environment, on-premise, private, ot public cloud. So, the enterprise can focus on building their application that creates an impact for its bussiness value. Awan IO and SWG have worked together to build and develop the platform that leverages the advantages of IBM Power Systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-w6xTjfolosrSelr2dbtZA.jpeg" /><figcaption>Awan IO Dashboard</figcaption></figure><p>Awan IO on IBM Power System is perfect for organizations that need performance, resiliency, scalability, and ease of application development because awan IO can orchestrate the infrastructure that we have such as Servers, CPU, Memory, Storage, and Network to enhance experience from developer to the end customer. Organizations like having cloud services in their own environment. The services we can get are :</p><ul><li><strong>Compute</strong> : allows users to launch virtual instances and have full control over the configuration and management of those instances</li><li><strong>Volumes</strong> : users get durable and persistent block-level storage volumes that can be attached to virtual instances, providing data persistence even if the instance is terminated or terminated</li><li><strong>Network</strong> : allows users to create logically isolated virtual networks on the Awan IO platform, users can define their own virtual network topology, configure IP addresses, create subnets, and control network access to their Awan IO resources.</li><li><strong>Object Storage : </strong>allows users to store and retrieve any type of data, such as documents, images.</li></ul><h4>Developing Open Source Software Using Awan IO on IBM Power System</h4><p>first of all, we created a common scenario that is often encountered in application development, we will create a product catalog apps that accepts input in the form of JSON data format from the user and then the data will be inserted into the postgreSQL database. we also want to involve messaging technology because messaging is one of the integration patterns between applications that commonly used in application development. so, the data submitted by the user will be inserted in a kafka topic as well. In addition, we also want to test whether the container technology can run to support application functions. so we decided to run postgreSQL database in docker container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6UXVCOrdhqw9jpEZ5fwRzg.png" /><figcaption>High Overview Scenario</figcaption></figure><p>project link : <a href="https://github.com/asrori08/swg-power9">https://github.com/asrori08/swg-power9</a></p><p>by using the Awan IO on IBM Power System, I can create a virtual machine with the specifications we want. All I need to do is create a virtual machine name, OS, specify the amount of CPU, Memory, Storage and on which network the virtual machine runs. Awan IO will create the virtual machine and then Awan IO will give me an IP address to access the virtual machine. this is not much different from what I’ve done in cloud providers like AWS or GCP. I think this is an advantage of Awan IO. with Awan IO, i don’t need to learn a lot of new things, the cloud platform takes the concept of cloud service that we are already familiar with and apply it to our infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qe0K0FWuGWBFkbYUrKaI4g.png" /><figcaption>list of virtual machines on the Awan IO platform</figcaption></figure><p>after provisioning virtual machine, then i write the code to develop java application in my local environment. my local environment has x86 architecture while the virtual machine I created earlier has ppc64le architecture. I’m not worried that my app won’t run because it has a different architecture, according to OSPAT (<a href="https://www.ibm.com/it-infrastructure/resources/power-open-source/">https://www.ibm.com/it-infrastructure/resources/power-open-source</a>), I can install the JDK (Java Development Kit) on a machine that has ppc64le architecture or i can use IBM semeru Runtime as well. this is an advantage because we do not need to spend more effort to port the application from x86 to ppc64le architecture. The IBM power system also offers support for modern programming languages such as Go and nodeJS, making it easier to start modernizing applications using refactor approach.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RoMv7AwFI23nIzCvUIb9bQ.png" /><figcaption>IBM OSPAT</figcaption></figure><p>to build the application, I recommend doing it directly on a machine that has a ppc64le architecture to make it easier to debug when there are incompatible libraries and besides minimizing the troublesome steps (following long steps of porting or installing various kinds of tools), another solution that can be tried is the IBM Cloud PowerVS service to build and to test the application, its simple and cheap.</p><p>to run the application, we need support services such as docker, postgreSQL and kafka. fortunately IBM Power System has broad support for open source technologies. to run containerized applications and create a kafka topic that accepts messages from product catalog apps, I didn’t find any issues, instead product catalog apps feels more powerful while still consumes less resources.</p><p><a href="https://drive.google.com/file/d/1ovs10s_v6fZwbQoiwcVPAqkRsZPlE63Q/view?usp=sharing">Screencast from 2023-03-10 13-41-29.webm</a></p><p>in short, building and running applications feels seamless, what I feel is there is no difference in my experience when I develop applications on platforms that have x86 architecture. Awan IO on IBM Power System has proven to me that the experience of using open source technology to develop modern applications can be found here and it’s even better because Awan IO on IBM Power System can support all the functions that the cloud platform has so that organizations will have a platform that is powerful, resilient, scalable and easy to use to support agile businesses.</p><h3>Summary</h3><p>In conclusion, open-source technology has significantly impacted the software industry. By combining Awan IO platform and the strengths of IBM Power System, organizations can unlock new possibilities, drive innovation, and achieve their business objectives. Organizations can also stay ahead of the competition by embracing open-source software and leveraging IBM Power Systems capabilities.</p><h4>References :</h4><p>RedHat. 2019. <a href="https://www.redhat.com/en/topics/open-source/what-is-open-source">What Is Open Source ?</a></p><p>IBM, <a href="https://www.ibm.com/topics/application-modernization">What is application modernization?</a></p><p>Reock, Justin. 2020. <a href="https://www.openlogic.com/blog/top-5-benefits-open-source-software">Open Source Benefit</a></p><p>Kaneriya, Tejas. 2023, <a href="https://www.storagereview.com/news/survey-of-ibm-power-customers-reveals-business-strategies">Application Modernization Strategy: 8 Steps to Success</a></p><p>Fritts, Harold. 2023. <a href="https://www.storagereview.com/news/survey-of-ibm-power-customers-reveals-business-strategies">Survey of IBM Power Customers Reveals Business Strategies</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44a4bbe5922f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concurrency di Go — Sync Package]]></title>
            <link>https://ahmad-asrori.medium.com/concurrency-di-go-sync-package-d59c2d85ddd3?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d59c2d85ddd3</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Sun, 08 Nov 2020 09:08:36 GMT</pubDate>
            <atom:updated>2020-11-08T09:08:36.818Z</atom:updated>
            <content:encoded><![CDATA[<h3>Concurrency di Go — Sync Package</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/855/1*F3InTJq7aDemxtgkNYanGQ.jpeg" /></figure><p>sync package berisi fungsi fungsi untuk menangani primitive concurrency yang berguna untuk low level memory access synchronization. Jika pembaca pernah menulis kode program dalam bahasa pemrograman yang ada fitur concurrency handler melalui memory access synchronization, fungsi fungsi pada package ini mungkin sudah tidak asing lagi bagi Anda. Perbedaan antara bahasa-bahasa lain dan Go adalah bahwa Go telah menyediakan satu set fungsi fungsi baru untuk menangani primitive concurrency memory access. setiap tipe data di package ini memiliki kegunaannya sendiri sendiri. Terserah kita untuk memutuskan kapan memory access synchronizationnya dilakukan.</p><h3><strong>WaitGroup</strong></h3><p>WaitGroup adalah cara yang bagus untuk menunggu satu set concurrent operation selesai dengan kondisi</p><ul><li>kita tidak peduli dengan hasil concurrent operation,</li><li>kita memiliki cara lain untuk mengumpulkan hasil dari concurrent operation.</li></ul><p>jika pembaca menginginkan kondisi dimana harus mendapatkan hasil dari concurrent operation maka pembaca bisa menggunakan channel dan select.</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>   &quot;time&quot;<br>)<br><br>func main() {<br>   var wg sync.WaitGroup<br><br>   wg.Add(2)<br>   go sayHello1(&amp;wg)<br>   go sayHello2(&amp;wg)<br><br>   wg.Wait()<br>   fmt.Println(&quot;all goroutine all complete&quot;)<br>}<br><br>func sayHello1(wg *sync.WaitGroup) {<br>   wg.Done()<br>   fmt.Println(&quot;1st goroutine sleeping&quot;)<br>   time.Sleep(1)<br>}<br><br>func sayHello2(wg *sync.WaitGroup) {<br>   wg.Done()<br>   fmt.Println(&quot;2nd goroutine sleeping&quot;)<br>   time.Sleep(2)<br>}</pre><p>pembaca dapat menganggap WaitGroup seperti concurrent-safe counter: method Add(delta int) akan menaikkan counter dengan integer yang dimasukkan sebagai parameter masukan, dan method Done() mengurangi counter satu per satu. panggil method Wait() ketika counter bernilai nol (artinya semua sudah selesai menjalankan rugas).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kBRIkc5seR9I-SV04PK4kw.png" /><figcaption>analogi waitgroup seperti to do list</figcaption></figure><p>perlu diperhatikan bahwa pemanggilan method Add(delta int) dilakukan <strong>diluar</strong> goroutine sebagai penanda untuk membantu melacak goroutine. jika kita tidak melakukan hal ini maka kita akan mengalami yang namanya <strong>race condition </strong>(mungkin kita akan mendapati program akan mengeksekusi method Wait sebelum menjalankan goroutine).</p><h3><strong>Mutex dan RWMutex</strong></h3><p>Jika pembaca sudah familiar menggunakan bahasa yang mempunyai fitur concurrency handler melalui memory access synchronization, pembaca mungkin akan langsung mengenali Mutex. Jika pembaca familiar, jangan khawatir, Mutex sangat mudah dipahami. Mutex adalah singkatan dari “mutual exclusion” dan merupakan cara untuk menjaga <strong>critical section </strong>(biasanya nilai dari suatu variabel) dari program.</p><p>Mutex memberikan kita cara yang aman untuk menggunakan exclusive access ke shared resource yang berada di memori. kebiasaan yang dilakukan programmer go, channel digunakan unuk berbagi memori dengan berkomunikasi, Mutex digunakan untuk <strong>berbagi memori dengan membuat “kesepatakan bersama” yang harus diikuti untuk sinkronisasi akses ke memori</strong>. kita bertanggung jawab untuk <strong>mengoordinasikan akses goroutine ke memori</strong> dan menjaga akses tersebut dengan mutex supaya goroutine tersebut memiliki hak exclusive untuk menggunakan resource tersebut.</p><p>Berikut adalah contoh sederhana dari dua goroutine yang mencoba untuk increment dan decrement nilai yang sama. kita coba menggunakan Mutex untuk menyinkronkan akses ke variabel count</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>)<br><br>func main() {<br>   var count int<br>   var lock sync.Mutex<br><br>   var arithmetic sync.WaitGroup<br>   for i := 0; i &lt;= 5; i++ {<br>      arithmetic.Add(1)<br>      go func() {<br>         defer arithmetic.Done()<br>         increment(&amp;lock, &amp;count)<br>      }()<br>   }<br>   <br>   for i := 0; i &lt;= 5; i++ {<br>      arithmetic.Add(1)<br>      go func() {<br>         defer arithmetic.Done()<br>         decrement(&amp;lock, &amp;count)<br>      }()<br>   }<br>   <br>   arithmetic.Wait()<br>   fmt.Println(&quot;complete.&quot;)<br>}<br><br>func increment(lock *sync.Mutex, count *int) {<br>   lock.Lock()<br>   defer lock.Unlock()<br>   *count++<br>   fmt.Printf(&quot;Incrementing: <strong>%d\n</strong>&quot;, *count)<br>}<br><br>func decrement(lock *sync.Mutex, count *int) {<br>   lock.Lock()<br>   defer lock.Unlock()<br>   *count--<br>   fmt.Printf(&quot;Decrementing: <strong>%d\n</strong>&quot;, *count)<br>}</pre><p>jika dijalankan maka akan ada banyak kemungkinan yang terjadi, mungkin jika pembaca menjalankan kode diatas akan berbeda output yang didapatkan dengan output berikut,</p><pre>&gt; go run mutex.go<br>Incrementing: 1<br>Decrementing: 0<br>Decrementing: -1<br>Decrementing: -2<br>Decrementing: -3<br>Incrementing: -2<br>Incrementing: -1<br>Decrementing: -2<br>Incrementing: -1<br>Incrementing: 0<br>Incrementing: 1<br>Decrementing: 0<br>Arithmetic complete.</pre><pre>&gt; go run mutex.go <br>Decrementing: -1<br>Incrementing: 0<br>Incrementing: 1<br>Incrementing: 2<br>Incrementing: 3<br>Incrementing: 4<br>Incrementing: 5<br>Decrementing: 4<br>Decrementing: 3<br>Decrementing: 2<br>Decrementing: 1<br>Decrementing: 0<br>Arithmetic complete.</pre><p>ketika kita ingin meminta hak exclusive / khusus untuk menggunakan resource dalam hal ini adalah variabel count. kita bisa memanggil method Lock(). pembaca pasti juga akan menyadari bahwa kita juga memanggil method Unlock() yang diawali dengan defer statement. cara ini umum digunakan jika kita ingin memanfaatkan mutex dengan memastikan pemanggilan (ke mutex) selalu terjadi, bahkan ketika terjadi panic. Gagal melakukan pemanggilan ke mutex mungkin akan menyebabkan program akan mengalami deadlock karena resource masih dipegang oleh goroutine yang lain dan antar goroutine akan saling menunggu mutex untuk me lock atau meng unlock resource.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HYP8LMYfAW0lGVMiKbVCDw.png" /></figure><p>adakalanya kita ingin meminimalisir frekuensi akses ke critical section karena critical section (shared resource) adalah tempat yang sangat mudah terjadi bottleneck. untuk masuk dan keluar dari critical section adalah sesuatu yang bisa kita anggap sebagai proses yang mahal. tidak semua proses membutuhkan hak ekslusif dalam menggunakan resource untuk melakukan operasi penuh (read dan write). mungkin ada proses yang hanya membutuhkan read saja atau write saja.</p><p>oleh karena itu, go menyediakan RWMutex. RWMutex memberikan kita kontrol yang sedikit lebih luas ke shared resource. kita bisa meminta hak akses untuk proses read saja. hak akses ini akan diberikan selama tidak ada proses lain yang memegang hak akses operasi write. berarti nantinya akan ada sembarang proses yang dapat melakukan read selama tidak ada proses lain yang memegang kunci hak akses write.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bEjw_O4ue38hDp5bhZMFDA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k_SmqZ-tQepO-33Ip8E5JA.png" /></figure><p>contoh program yang dibuat kali ini adalah producer dan observer. dimana kita akan melakukan perbandingan antara mutex dan RWMutex.</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;math&quot;<br>   &quot;os&quot;<br>   &quot;sync&quot;<br>   &quot;text/tabwriter&quot;<br>   &quot;time&quot;<br>)<br><br>func main() {<br>   producer := func(wg *sync.WaitGroup, l sync.Locker) {<br>      defer wg.Done()<br>      for i := 5; i &gt; 0; i-- {<br>         l.Lock()<br>         l.Unlock()<br>         time.Sleep(1)<br>      }<br>   }<br>   observer := func(wg *sync.WaitGroup, l sync.Locker) {<br>      defer wg.Done()<br>      l.Lock()<br>      defer l.Unlock()<br>   }<br><br>   test := func(count int, mutex, rwMutex sync.Locker) time.Duration {<br>      var wg sync.WaitGroup<br>      wg.Add(count+1)<br>      beginTestTime := time.Now()<br>      go producer(&amp;wg, mutex)<br>      for i := count; i &gt; 0; i-- {<br>         go observer(&amp;wg, rwMutex)<br>      }<br>      wg.Wait()<br>      return time.Since(beginTestTime)<br>   }<br><br>   tw := tabwriter.NewWriter(os.Stdout, 0, 1, 2, &#39; &#39;, 0)<br>   defer tw.Flush()<br>   var m sync.RWMutex<br>   fmt.Fprintf(tw, &quot;Readers<strong>\t</strong>RWMutext<strong>\t</strong>Mutex<strong>\n</strong>&quot;)<br>   for i := 0; i &lt; 20; i++ {<br>      count := int(math.Pow(2, float64(i)))<br>      fmt.Fprintf(tw, &quot;<strong>%d\t%v\t%v\n</strong>&quot;, count, test(count, &amp;m, m.RLocker()), test(count, &amp;m, &amp;m) )<br>   }<br>}</pre><p>jika dijalankan akan memiliki output seperti ini</p><pre>&gt; go run rwmutex.go<br>Readers  RWMutext      Mutex<br>1        21.325µs      2.934µs<br>2        9.142µs       34.314µs<br>4        8.499µs       12.26µs<br>8        21.648µs      42.556µs<br>16       39.203µs      12.018µs<br>32       29.798µs      35.143µs<br>64       77.067µs      85.761µs<br>128      99.606µs      80.429µs<br>256      105.801µs     70.128µs<br>512      158.111µs     159.98µs<br>1024     352.414µs     340.156µs<br>2048     580.72µs      576.038µs<br>4096     1.30446ms     1.140181ms<br>8192     2.122426ms    2.450201ms<br>16384    4.48796ms     4.461127ms<br>32768    9.302955ms    8.279684ms<br>65536    18.594497ms   17.742528ms<br>131072   37.124076ms   35.210006ms<br>262144   72.47442ms    80.241654ms<br>524288   149.705327ms  144.292868ms</pre><p>terlihat bahwa hasilnya cukup beragam, penggunaan mutex dan RWMutex tergantung kondisi tertentu.</p><h3><strong>Once</strong></h3><p>diberikan sebuah program sederhana untuk meng-increment angka</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>)<br><br>func main() {<br>   var count int<br><br>   increment := func() {<br>      count++<br>   }<br><br>   var once sync.Once<br>   var increments sync.WaitGroup<br>   increments.Add(100)<br><br>   for i := 0; i &lt; 100; i++ {<br>      go func() {<br>         defer increments.Done()<br>         once.Do(increment)<br>      }()<br>   }<br><br>   increments.Wait()<br>   fmt.Printf(&quot;Count is <strong>%d\n</strong>&quot;, count)<br>}</pre><p>jika pembaca menebak hasilnya adalah 100, maka tebakan anda salah, namun anda pasti melihat bahwa ada variabel bertipe sync.Once.</p><p>Seperti namanya, sync.Once adalah tipe yang menggunakan beberapa primitive synchronization secara internal untuk memastikan bahwa program hanya memanggil <strong>tepat</strong> <strong>satu kali</strong> fungsi increment melalui method Do bahkan pada goroutine yang berbeda. kelihatannya fungsi untuk memanggil suatu fungsi tepat satu kali<strong> </strong>adalah hal yang baru saya temui dan fungsi ini dimasukkan ke dalam standard package, tetapi kadang kadang kita memerlukan juga hal ini.</p><p>contoh lagi</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>)<br><br>func main() {<br>   var count int<br>   <br>   increment := func() { count++ }<br>   decrement := func() { count-- }<br>   <br>   var once sync.Once<br>   once.Do(increment)<br>   once.Do(decrement)<br>   <br>   fmt.Printf(&quot;Count is <strong>%d\n</strong>&quot;, count)<br>}</pre><p>jika pembaca menebak bahwa variabel count hasilnya adalah 0 maka anda salah, hasilnya adalah 1. yang pelu diketahui bahwa method Do <strong>hanya</strong> <strong>menghitung</strong> <strong>berapa kali method Do dipanggil, bukan berapa banyak fungsi yang berbeda di masukkan ke method tersebut.</strong></p><h3><strong>Pool</strong></h3><p>Pool adalah concurrent-safe implementation dari object pool pattern. Penjelasan lengkap tentang pool pattern ada di buku design pattern. tetapi, saya akan coba jelaskan sedikit. secara garis besar, pool pattern adalah sebuah c<strong>ara untuk membuat sesuatu dengan jumlah yang tetap (fixed number)</strong>. biasanya digunakan untuk membuat hal yang bisa dikatakan <strong>mahal</strong> seperti database connection. tetapi sejumlah operasi masih dapat meminta akses ke sesuatu itu.</p><p>interface sync.Pool memiliki metode Get. Saat dipanggil, Get pertama-tama akan memeriksa apakah ada instance/objek yang tersedia di dalam pool untuk dikembalikan ke pemanggil, dan jika tidak, panggil New untuk membuat instance baru, Setelah selesai, pemanggil memanggil method Put untuk menempatkan instance tempat mereka bekerja kembali ke pool untuk digunakan oleh proses lain.</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>)<br><br>func main() {<br>   myPool := &amp;sync.Pool{<br>      New: func() interface{} {<br>         fmt.Println(&quot;Creating new instance.&quot;)<br>         return struct{}{}<br>      },<br>   }</pre><pre>   // method Get akan memeriksa objek yang ada di pool, jika belum ada objek maka akan otomatis dibuatkan objek dengan memanggil method New, <br>   myPool.Get()<br>   instance := myPool.Get()</pre><pre>   // mengembalikan ke pool<br>   myPool.Put(instance)<br>   // mangambil instance dari pool, dalam hal ini program tidak perlu lagi memanggil fungsi New karena sudah ada instance di pool<br>   myPool.Get()<br>}</pre><p>ada situasi lagi dimana pool bisa berguna yaitu untuk melakukan warming cache dari objek yang telah dialokasikan sebelumnya dan objek ini digunakan untuk melakukan operasi yang harus berjalan secepat mungkin. daripada mencoba menjaga ukuran memori agar tetap kecil dengan membatasi jumlah objek yang dibuat, kita mencoba menjaga waktu consumer dengan memuat objek tersebih dahulu. cara ini umum digunakan saat ada aplikasi yang memerlukan high throughput network server yang mencoba memberikan request response yang cepat.</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>)<br><br>func main() {<br>   var numCalcsCreated int<br>   calcPool := &amp;sync.Pool {<br>      New: func() interface{} {<br>         numCalcsCreated += 1<br>         mem := make([]byte, 1024)<br>         return &amp;mem<br>      },<br>   }</pre><pre>   // buat 4 objek<br>   calcPool.Put(calcPool.New())<br>   calcPool.Put(calcPool.New())<br>   calcPool.Put(calcPool.New())<br>   calcPool.Put(calcPool.New())</pre><pre>   const <strong><em>numWorkers </em></strong>= 1024*1024<br>   var wg sync.WaitGroup<br>   wg.Add(<strong><em>numWorkers</em></strong>)<br><br>   for i := <strong><em>numWorkers</em></strong>; i &gt; 0; i-- {<br>      go func() {<br>         defer wg.Done()<br>         mem := calcPool.Get().(*[]byte)<br>         defer calcPool.Put(mem)<br>         // asumsikan terjadi sesuatu disini<br>      }()<br>   }<br>   wg.Wait()<br>   fmt.Printf(&quot;<strong>%d</strong> calculators were created.&quot;, numCalcsCreated)<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*txoWKsJa_wTWTwon9FTYiQ.png" /></figure><p>object pool pattern paling baik digunakan saat memiliki concurrent process yang memerlukan objek, tetapi mengembalikan objek dengan sangat cepat ke pool setelah pembuatan objek, atau saat konstruksi objek ini dapat membuat hal yang tidak baik bagi memori.</p><p>Further Reading</p><p><a href="https://medium.com/a-journey-with-go/go-understand-the-design-of-sync-pool-2dde3024e277">https://medium.com/a-journey-with-go/go-understand-the-design-of-sync-pool-2dde3024e277</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d59c2d85ddd3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Integration at 20.000 feet — Messaging System]]></title>
            <link>https://ahmad-asrori.medium.com/integration-at-20-000-feet-messaging-system-ed92104d3d4a?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed92104d3d4a</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Wed, 04 Nov 2020 16:59:53 GMT</pubDate>
            <atom:updated>2020-11-04T17:14:12.056Z</atom:updated>
            <content:encoded><![CDATA[<h3>Integration at 20.000 feet — Messaging System</h3><h3><strong>Intro</strong></h3><p>pada artikel sebelumnya telah dibahas mengenai macam macam cara untuk menghubungkan atau mengintegrasikan aplikasi, termasauk salah satunya adalah messaging. messaging membuat aplikasi menjadi bersifat loosely coupled dengan menggunakan jenis komunikasi yang bersifat asynchronous, yang juga membuat komunikasi menjadi lebih reliable karena antar aplikasi yang terhubung tidak harus berjalan secara bersamaan. messaging membuat messaging system melakukan tugas untuk mentransfer / mengirimkan data dari satu aplikasi ke aplikasi yang lain (bisa disebut sebagai message broker). jadi aplikasi dapat fokus ke data yang dikirimkan tanpa khawatir bagaimana cara mengirim data tersebut.</p><h3><strong>Konsep Dasar Messaging</strong></h3><p>konsep konsep dasar messaging yang penulis sampaikan disini adalah konsep secara genarl dan tidak terikat pada teknologi messaging system manapun.</p><p><strong>Channels</strong> — messaging system mengirimkan data melalui message channel, channel bisa disebut sebagai sebuah pipa yang menghubungkan <strong>sender</strong> dengan <strong>receiver. </strong>biasanya messaging system yang baru diinstall tidak mempunyai channel, kita harus membuat channel terlebih dahulu supaya aplikasi dapat berkomunikasi satu sama lain. (istilah kekiniannya adalah topic)</p><p><strong>Messages</strong> — Message adalah data yang dapat dikirim melalui channel. Jadi untuk mengirimkan data, sender harus memecah data menjadi satu atau lebih data, membungkus setiap data sebagai message, dan kemudian mengirim message tersebut ke channel. kemudian, receiver menerima pesan dan harus mengekstrak data dari pesan tersebut dan memprosesnya. Sistem pesan akan mencoba berulang kali untuk menyampaikan pesan (misalnya, mengirimkannya dari sender ke receiver) sampai berhasil (berkaitan dengan message delivery guarantee).</p><p><strong>Multi-Step Delivery</strong> — Dalam kasus yang paling sederhana, message system mengirimkan message langsung dari sender ke receiver. Namun, ada tindakan tindakan yang sering kali perlu dilakukan pada message setelah dikirim oleh sender dan sebelum diterima oleh receiver. Misalnya :</p><ul><li>message mungkin harus divalidasi atau diubah karena receiver mengharapkan format message yang berbeda dari sender,</li><li>message yang sampai di messaging system disimpan terlebih dahulu di memory, file, atau persistence storage (database)</li><li>message yang sudah disimpan kemudian direplikasi ke tempat yang lain</li></ul><p><strong>Routing</strong> — dengan banyaknya aplikasi dan channel yang menghubungkan mereka, sebuah message mungkin melewati beberapa channel sampai akhirnya sampai ke final receiver. Rute yang harus diikuti message mungkin sangat rumit sehingga sender tidak tahu channel mana yang membawa message sampai ke final receiver.</p><p><strong>Transformation</strong> — Berbagai aplikasi mungkin tidak sepakat dengan format data yang digunakan; sender memformat message dengan satu cara, namun receiver mengharapkannya diformat dengan cara lain. Untuk menyamakan hal message ini, message harus melalui intermediate filter yaitu message translatoe yang mengonversi message dari satu format ke format lainnya.</p><p><strong>Endpoints</strong> — Aplikasi tidak memiliki kemampuan untuk berinteraksi dengan messaging system. Sebaliknya, aplikasi harus berisi code layer yang mengetahui cara kerja aplikasi dan cara kerja messaging system, menghubungkan keduanya sehingga keduanya bekerja sama. biasanya dengan menggunakan library client yang telah disediakan oleh masing masing messaging system maka aplikasi dan messaging bisa saling terhubung.</p><h3><strong>Message Delivery Guarantee</strong></h3><p><strong>berawal dari two generals’ problem</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RBZGjEYFQ4WPjxdKRHRepA.png" /></figure><p>two general problem, ceritanya dimana ada 2 jendral beserta pasukannya yang sepakat akan menyerang benteng yang terletak ditengah tengan lembah, kedua jendral ini tahu bahwa untuk menaklukan benteng tersebut diperlukan kerjasama antara kedua pasukan, benteng tersebut dapat ditaklukkan jika kedua pasukan menyerang pada waktu yang bersamaan. oleh karena itu jendral A harus memberitahu ke jendral B melalui pesan yang dikirim oleh <strong>kurir. </strong>kurir menyampaikan pesan tersebut dari jendral A ke jendral B dengan melewati lembah dan benteng yang berada ditengah tengahnya.</p><ul><li><strong>At Most Once</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k2_podldPIMfqwa5PPHXTA.png" /></figure><p>jendral A tinggal mengutus kurir untuk menyampaikan pesan ke jendral B, namun pesan tersebut harus melewati benteng dan jika kurir tersebut di cegat didaerah benteng dan pesan yang dikirimkan oleh jendral A dibaca oleh musuh maka rencananya akan gagal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MyqCewY855IMXJkJz6_yIA.png" /></figure><p>diketahui service A sebagai sender dan service B sebagai receiver, service A hanya mengirim message tanpa mengetahui service B akan menerima message tersebut atau tidak (fire and forget). model at most once ini sangat mudah diimplementasikan, high performance, dan tidak gampang overhead karena sender tidak menyimpan state apapun saat message selesai dikirim ke message system. kekurangannya adalah tidak ada jaminan message sampai ke receiver.</p><ul><li><strong>At Least Once</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VFpuU02yEhqveUzKAr6znQ.png" /></figure><p>jendral A mengirim pesan ke jendral B dan berharap pesan tersebut tidak dicegat oleh musuh, ketika pesan tersebut sampai ke jendral B, jendral B membalas pesan tersebut misal seperti “ok, aku mengerti” (sebagai konformasi/acknowledgement) dan mengirimkannya kembali ke jendral A.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*leSUT62yRDBZQYqEjML3NQ.png" /></figure><p>syukur syukur pesan yang dikirim oleh jendral B tidak dicegat oleh musuh. jika hal tersebut terjadi maka mau tidak mau jendral A mengirim pesan lagi ke jendral B, sehingga jendral B dapat mempunyai lebih dari 1 pesan yang sama. begitu seterusnya sampai jendral A mendapatkan konfirmasi dari jedral B.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TqDUi_TABnU-hwlZ4MSGqA.png" /></figure><p>diketahui service A sebagai sender dan service B sebagai receiver, dalam model ini sender dapat melakukan pengiriman ulang (mengirim message), disini sender mempertahankan status pengiriman message sampai memiliki acknowledgment (konfirmasi balasan) dari pihak receiver. receiver dapat memiliki lebih dari satu message yang sama. jadi ada message yang diproses sebanyak 2 kali, model ini mempunyai kelebihan yaitu jaminan message pasti sampai ke receiver namun kekurangannya adalah ada kasus dimana pesan tersebut dapat diterima dan diproses lebih dari satu kali oleh receiver.</p><p>hal ini (pesan yang diproses 2 kali) tentunya tidak diinginkan jika ada service mengerjakan hal hal yang berbau mission critical (contohnya seperti finansial). misalnya. salah penanganan dapat membuat jumlah saldo bisa berkurang atau bertambah berkali kali lipat.</p><ul><li><strong>Exactly Once</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hKDhX7xFtPo53Ope3Gqvrw.png" /></figure><p>jendral A mengirim pesan ke jendral B dan jendral B memproses hanya satu kali pesan tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2rK_vG8K-XoJpSCGen6g4w.png" /></figure><p>diketahui service A sebagai sender dan service B sebagai receiver, disini message akan dijamin sampai ke receiver. sender menjamin bahwa message yang dikirim hanya satu, diterima dan diproses oleh receiver sebanyak hanya satu kali. biasanya model ini digunakan untuk hal hal yang berbau mission critical.</p><p>sayangnya model ini sangat sulit (atau mustahil) untuk diterapkan bahkan message system seperti kafka yang mengklaim bahwa mereka sudah menerapkan exactly once, itupun tidak murni memakai model exactly once, hanya semanticnya (seolah olah menggunakan) saja.</p><p>berikut beberapa messaging system dan message delivery guaranteenya</p><ul><li>Apache Kafka : at least once, exactly once</li><li>Apache RabbitMQ : at most once, at least once</li><li>NATS : at most once, at least once</li></ul><h3><strong>Pattern In Messaging System</strong></h3><p><strong>Message Queue</strong></p><p>message queue adalah salah satu bentuk komunikasi antar service menggunakan messaging yang bersifat asynchronous dimana message yang telah dikirimkan oleh sender akan disimpan di <strong>queue</strong> dan message tersebut akan dikirimkan ke receiver untuk diproses. message yang sudah terkirim ke sender akan otomatis terhapus didalam queue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cYMM_9JIngpScZgW2hmCWA.png" /></figure><p><strong>Publish / Subscribe</strong></p><p>publish-subscribe adalah salah satu bentuk komunikasi antar service menggunakan messaging yang bersifat asynchronous dimana sender akan mengirimkan message ke topic. message yang berada di topic otomatis akan diterima oleh reciever yang men-subscribe topic tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rxb2omtm_e2Q_XNzqLy_5w.png" /></figure><p><strong>Load Balancing</strong></p><p>load balancing sendiri adalah sebuah metode untuk mendisribusikan message secara merata ke sebuah grup</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xyc234g56wNgdtMujsf1fQ.png" /></figure><h3>Tantangan dan Strategi Saat Implementasi Messaging</h3><p>selama kurang dari 2 minggu saya mencoba memakai apache kafka, saya mengalami beberapa tantangan yang cukup menarik untuk diselesaikan, saya coba berbagi mencoba berbagi informasi mengenai tantangan apa saja yang dihadapi saat implementasi kafka.</p><p><strong>graceful Shutdown</strong></p><p>tentu kita mengharapkan aplikasi yang dideploy ke production dapat berjalan dengan baik, namun ada baiknya kita tetap memerhatikan kondisi kondisi yang mungkin saja terjadi salah satunya adalah aplikasi tiba tiba mati entah itu disebabkan oleh hardware maupun software. kalau server tiba tiba mati ya kita tidak bisa berbuat apa apa, otomatis aplikasi akan terkena masalah karena mungkin ketika servernya mati, aplikasi sedang melakukan pemrosesan message. kemungkinan besar message tersebut gagal diproses. jika terjadi hal tersebut solusinya adalah dengan mereplay kembali message tersebut dari kafka topic.</p><p>tidak ada yang tahu apa yang akan terjadi di production, worst casenya adalah listrik tiba tiba mati. bagaimana jika sistem operasi yang digunakan tiba tiba melakukan auto update sehingga nantinya sistem operasi akan restart. kalau sistem operasi yang digunakan restart, semua aplikasi yang berjalan diatas sistem operasi akan dikirimi signal oleh sistem operasi. nah signal tersebut adalah sebagai “rambu” untuk kita agar segera menghentikan semua aktifitas pemrosesan message.</p><p><a href="https://gist.github.com/Ahmad-Asrori/beb2e9c1a570e044da4d65ec48bd2e57">https://gist.github.com/Ahmad-Asrori/beb2e9c1a570e044da4d65ec48bd2e57</a></p><p>pada source code diatas saya menggunakan goroutine untuk memproses message yang masuk, message yang masuk akan ditulis di console dan file. ketika program menerima signal dari OS, program akan menunggu goroutine yang sedang mengerjakan task untuk segera menyelesaikan message processing. setelah semua task selesai, pointer ke file ditutup dan objek consumer ditutup (dihapus dari GC).</p><p><strong>Message Processing</strong></p><p>setiap message yang diterima oleh receiver, biasanya receiver akan mambuat thread (jika pembaca menggunakan bahasa seperti java) untuk memproses message tersebut. karena saya memakai go, biasanya di go akan membuat goroutine untuk memproses setiap message yang masuk (tergantung kita juga mau pakai goroutine atau tidak). ada baiknya kita membatasi penggunaan semacam goroutine ini sehingga kita dapat menghindari penggunaan resource (CPU dan memori) yang berlebihan. meskipun goroutine dapat dibuat sampai jumlah yang sangat banyak, namun kita sendiri harus bijak dalam penggunaan resource.</p><p>solusinya adalah dengan mengimplementasikan yang namanya goroutine pool. apa maksudnya? kita menyediakan sejumlah goroutine yang memproses message. katakanlah 15 goroutine (sebagai contoh, namun pada kenyataanya bisa mencapai ribuan). misal ada 3 message yang datang maka receiver akan mengambil 3 goroutine dari goroutine pool untuk memproses message tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LI3V8jx2zrRk0wse0X0scQ.png" /></figure><p>ketika ada goroutine yang selesai memproses message tersebut, maka goroutine akan dikembalikan ke goroutine pool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_uaBXn8S3uWfkjAQOrAA7A.png" /></figure><p>dengan melakukan cara tersebut, diharapkan kita terhindar dari masalah penggunaan CPU dan memori secara berlebihan. disini saya menggunakan library dari <a href="https://github.com/panjf2000/ants">https://github.com/panjf2000/ants</a> untuk mengimplementasikan goroutine pool.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6feff350735fdd6d4a41610148466000/href">https://medium.com/media/6feff350735fdd6d4a41610148466000/href</a></iframe><p><strong>Consumer Operating Expenses</strong></p><p>dengan mengimplementasikan goroutine pool, kita membatasi ada sejumlah goroutine yang digunakan untuk melakukan message processing. memang kedengarannya kurang menyenangkan karena performa receiver dibatasi. namun kita tidak akan tahu apa yang akan terjadi di production (soalnya kita bukan dukun, hehe) misal receiver mati dalam 3 menit. disini pentingnya menggunakan goroutine pool untuk mengetahui beban receiver dalam message processing, karena goroutine jumlahnya sudah kita tentukan diawal maka kita dapat melakukan benchmark untuk melakukan perhitungan kasar berapa message yang dapat diproses oleh receiver dalam 1 menit.</p><p>katakanlah kita sudah punya hitungan kasar bahwa receiver dapat memproses message sebanyak 9k/menit, diproduction dia memproses message sebanyak 6k/menit, ketika receiver tersebut down (karena node mati atau ada update OS) selama 3 menit maka ada sekita 18k message yang berada di messaging system. pertanyaannya, jika kita menjalankan kembali receiver apa yang akan terjadi? receiver akan “dihujani” message sebanyak 18k secara simultan sehingga receiver tidak bisa menemukan kondisi ideal untuk memproses message.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oT4uuyOY034tbg16JmaKlw.png" /></figure><p>solusinya bagaimana ? kita bisa menambahkan 1 atau 2 receiver, membuat dan menambahkannya ke consumer group, sehingga message workloadnya terbagi rata ke semua receiver (round robin)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xU9erTA5EsYKM8T_fY0K9w.png" /></figure><p><strong>Reconnect Mechanism</strong></p><p>ketika messaging system down, baik sender maupun receiver tidak bisa melakukan aktifitas mengirim atau menerima message dalam waktu tertentu. untuk itu kita perlu melakukan mekanisme reconnect untuk mengetahui apakah messaging system sudah up atau belum. biasanya client library yang disediakan sudah dapat melakukan mekanisme reconnect.</p><p><strong>Duplication Of Message</strong></p><p>jika pembaca menggunakan messaging system dengan delivery guarantee at least once (kafka, rabbitMQ, dll) maka pembaca pasti menemukan ada message yang diproses sebanyak lebih dari satu kali, hal ini tentunya sangat tidak diinginkan. lalu bagaimana solusinya ? dengan menggunakan <strong>idempotency token.</strong></p><p>jadi caranya adalah setiap message akan diberi token / id khusus sebagai pembeda antara satu message dengan message yang lain. ketika message tersebut sampai di receiver, message tersebut akan diambil idnya kemudian id tersebut kita cari di database (misalnya redis) kalau id tersebut belum ada maka simpan id tersebut didatabase. dan message tersebut bisa di proses lebih lanjut oleh receiver.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U1cArn-DoyYKYKn2WbXoeg.png" /></figure><p>jika ada message dengan id M1 kembali diterima, maka langkahnya masih sama seperti diatas yaitu cari id nya di database jika id tersebut ada maka message tersebut tidak boleh diproses lagi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x5kJfK0CyaBNgZXJ4NC34g.png" /></figure><p>kemudian muncul pertanyaan, id tersebut ditempatkan dimana? bisa di bagian key saat producer hendak mengirim message ke messaging system. lalu berapa lama redis menyimpan key tersebut? saya belum bisa menjawab, banyak hal yang harus dipertimbangkan misalnya jumlah message, kapasitas memory (karena pakai redis), dan lain sebagainya.</p><p>solusi ini muncul dari two general problem diatas, saya hanya memberikan konsepnya, pembaca bisa mengimplementasikannya di messaging system apapun.</p><h3><strong>kesimpulan</strong></h3><p>ada harga ada rupa, begitulah yang orang orang sering katakan, messaging adalah salah satu cara komunikasi antar service. dimana saat ini banyak digunakan di arsitektur microservice. messaging menyelesaikan masalah kompleksitas arsitektur aplikasi yang semakin meningkat, scalability, dan reliability. namun dibalik itu semua ada harga yang harus dibayar ketika menggunakannya.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed92104d3d4a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testing Golang Application]]></title>
            <link>https://ahmad-asrori.medium.com/testing-golang-application-e3a8f720f814?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e3a8f720f814</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Fri, 23 Oct 2020 02:11:28 GMT</pubDate>
            <atom:updated>2020-10-23T02:11:28.227Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Menulis Unit Test</strong></h3><p>golang mempunyai package yang bernama testing yang menyediakan dukungan untuk menulis unit test. perintah go test menjalankan unit test yang ditulis menggunakan testing package.</p><p>file calc.go</p><pre>package calc<br><br>import &quot;math&quot;<br><br>func Sum(numbers ...int) int {<br>   result := 0<br>   for _, v := range numbers {<br>      result += v<br>   }</pre><pre>   return result<br>}<br><br>func Average(numbers ...int) float64 {<br>   sum := 0<br>   for _, v := range numbers {<br>      sum += v<br>   }</pre><pre>   result := float64(sum) / float64(len(numbers))<br>   pow := math.Pow(10, float64(2))<br>   digit := pow * result<br>   round := math.Floor(digit)</pre><pre>   return round / pow<br>}</pre><p>file calc_test.go</p><pre>package calc<br><br>import &quot;testing&quot;<br><br>func TestSum(t *testing.T) {<br>   input, expected := []int{7, 8, 10}, 25<br>   result := Sum(input...)<br>   if result != expected {<br>      t.Errorf(&quot;Result: <strong>%d</strong>, Expected: <strong>%d</strong>&quot;, result, expected)<br>   }<br>}<br><br>func TestAverage(t *testing.T) {<br>   input, expected := []int{7, 8, 10}, 8.33<br>   result := Average(input...)<br>   if result != expected {<br>      t.Errorf(&quot;Result: <strong>%f</strong>, Expected: <strong>%f</strong>&quot;, result, expected)<br>   }<br>}</pre><p>kemudian jalankan perintah go test di direktori package calc</p><pre>&gt; go test           <br>PASS<br>ok      github.com/Ahmad-Asrori/simple/calc     0.002s</pre><p>jika pembaca ingin mengetahui lebih detail, pembaca dapat menambahkan flag -v</p><pre>&gt; go test -v<br>=== RUN   TestSum<br>--- PASS: TestSum (0.00s)<br>=== RUN   TestAverage<br>--- PASS: TestAverage (0.00s)<br>PASS<br>ok      github.com/Ahmad-Asrori/simple/calc     0.001s</pre><p>pembaca bisa mengetahui seberapa banyak test yang berhasil dijalankan dengan menambahkan flag -cover</p><pre>&gt; go test -v -cover<br>=== RUN   TestSum<br>--- PASS: TestSum (0.00s)<br>=== RUN   TestAverage<br>--- PASS: TestAverage (0.00s)<br>PASS<br>coverage: 100.0% of statements<br>ok      github.com/Ahmad-Asrori/simple/calc     0.001s</pre><h3><strong>Melompati Suatu Test Case</strong></h3><p>adakalanya kita perlu melompati tes karena alasan tertentu misalnya terlalu banyak memakan waktu atau memang test case tersebut tidak relevan.</p><p>di file calc_test.go tambahkan</p><pre>func TestLongRun(t *testing.T) {<br>   if testing.Short() {<br>      t.Skip(&quot;Skipping test&quot;)<br>   }<br>   time.Sleep(5 * time.<strong><em>Second</em></strong>)<br>}</pre><p>kemudian jalankan dengan perintah go test -v -short</p><pre>&gt; go test -v -short<br>=== RUN   TestSum<br>--- PASS: TestSum (0.00s)<br>=== RUN   TestAverage<br>--- PASS: TestAverage (0.00s)<br>=== RUN   TestLongRun<br>    calc_test.go:26: Skipping test<br>--- SKIP: TestLongRun (0.00s)<br>PASS<br>ok      github.com/Ahmad-Asrori/simple/calc     0.002s</pre><h3><strong>Benchmark</strong></h3><p>package testing memungkinkan kita untuk melakukan benchmark terhadap kode program. Untuk menulis benchmark, tulis fungsi dengan pattern func BenchmarkXxx (* testing.B), dan jalankan dengan perintah go test -bench.</p><p>di file calc_test.go tambahkan kode berikut</p><pre>func BenchmarkSum(b *testing.B) {<br>   for i := 0; i &lt; b.N; i++ {<br>      Sum(7, 8, 10)<br>   }<br>}<br><br>func BenchmarkAverage(b *testing.B) {<br>   for i := 0; i &lt; b.N; i++ {<br>      Average(7, 8, 10)<br>   }<br>}</pre><p>kemudian jalankan dengan perintah go test -v -bench</p><pre>&gt; go test -v -short -bench .<br>=== RUN   TestSum<br>--- PASS: TestSum (0.00s)<br>=== RUN   TestAverage<br>--- PASS: TestAverage (0.00s)<br>goos: linux<br>goarch: amd64<br>pkg: github.com/Ahmad-Asrori/simple/calc<br>BenchmarkSum<br>BenchmarkSum-4          229425619                5.13 ns/op<br>BenchmarkAverage<br>BenchmarkAverage-4      32393780                37.3 ns/op<br>PASS<br>ok      github.com/Ahmad-Asrori/simple/calc     2.960s</pre><p>artinya didalam function BenchmarkSum dilakukan perulangan sampai 229.425.619 kali dan setiap perulangan memakan waktu 5.12 nanosecond.</p><h3><strong>Menjalankan Tes Secara Paralel</strong></h3><p>kita dapat menjalankan test secara paralel dengan memanggil method Parallel yang bertipe Testing.T didalam function unit test</p><p>di file calc_test.go tambahkan kode berikut</p><pre>func TestSumInParallel(t *testing.T) {<br>   t.Parallel()<br>   // Delay 1 detik untuk tujuan demonstrasi<br>   time.Sleep(1 * time.<strong><em>Second</em></strong>)<br>   input, expected := []int{7, 8, 10}, 25<br>   result := Sum(input...)<br>   if result != expected {<br>      t.Errorf(&quot;Result: <strong>%d</strong>, Expected: <strong>%d</strong>&quot;, result, expected)<br>   }<br>}<br><br>func TestAverageInParallel(t *testing.T) {<br>   t.Parallel()<br>   // Delay 1 detik untuk tujuan demonstrasi<br>   time.Sleep(2 * time.<strong><em>Second</em></strong>)<br>   input, expected := []int{7, 8, 10}, 8.33<br>   result := Average(input...)<br>   if result != expected {<br>      t.Errorf(&quot;Result: <strong>%f</strong>, Expected: <strong>%f</strong>&quot;, result, expected)<br>   }<br>}</pre><p>jalankan tes</p><pre>&gt; go test -v                <br>=== RUN   TestSum<br>--- PASS: TestSum (0.00s)<br>=== RUN   TestAverage<br>--- PASS: TestAverage (0.00s)<br>=== RUN   TestSumInParallel<br>=== PAUSE TestSumInParallel<br>=== RUN   TestAverageInParallel<br>=== PAUSE TestAverageInParallel<br>=== CONT  TestSumInParallel<br>=== CONT  TestAverageInParallel<br>--- PASS: TestSumInParallel (1.00s)<br>--- PASS: TestAverageInParallel (2.00s)<br>PASS<br>ok      github.com/Ahmad-Asrori/simple/calc     2.003s</pre><p>ketika menjalankan fungsi TestSumInParallel dan kemudian ada tes yang belum selesai maka go akan lanjut mengerjakan tes yang berikutnya</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3a8f720f814" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Integration at 20.000 Feet — Integrasi Aplikasi Secara Umum]]></title>
            <link>https://ahmad-asrori.medium.com/integration-at-20-000-feet-integrasi-aplikasi-secara-umum-bdd5cfb21436?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/bdd5cfb21436</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Wed, 21 Oct 2020 13:53:07 GMT</pubDate>
            <atom:updated>2020-10-25T01:53:45.335Z</atom:updated>
            <content:encoded><![CDATA[<h3>Integration at 20.000 Feet — Integrasi Aplikasi Secara Umum</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/877/1*OW1sHosHbLbTXyVymSsv1g.jpeg" /><figcaption>Sumber : <a href="https://www.channelfutures.com/files/2019/10/Putting-puzzle-pieces-together-877x432.jpg">https://www.channelfutures.com/files/2019/10/Putting-puzzle-pieces-together-877x432.jpg</a></figcaption></figure><h3>Intro</h3><p>seringkali saya mendengar orang orang berbicara mengenai arsitektur microservice akhir akhir ini. microservice sendiri merupakan sebuah cara atau pendekatan untuk mengembangkan sebuah aplikasi dengan memecah satu aplikasi yang besar (monolith) menjadi beberapa aplikasi kecil yang disebut sebagai service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-NN4XHvrtPIdp1T_wy7K4A.png" /><figcaption>Gambar 1 : ilustrasi sederhana mengenai monolith &amp; microservice</figcaption></figure><p>ciri umum dari service adalah sebagai berikut</p><ul><li>setiap service berjalan sendiri sendiri dan dapat saling berkomunikasi satu sama lain (biasanya dengan RESTful API).</li><li>setiap service dibuat berdasarkan domain bisnisnya (fokus kepada satu tugas &amp; spesifik)</li><li>setiap service dapat dideploy secara independen menggunakan CI/CD tools (supaya berjalan otomatis)</li><li>setiap service dapat ditulis dengan bahasa pemrograman yang berbeda dengan service yang lain dan juga setiap service dapat menggunakan teknologi database yang berbeda</li></ul><p>setelah mengetahui ciri umum dari service saya teringat dengan desain command line di linux, jika pembaca pernah mempelajari mengenai konsep pipes dan redirection pasti pembaca menyadari bahwa desain arsitektur microservice hampir mirip dengan desain command line di linux. di linux sendiri command line seperti cd, ls, cat dan lain sebagainya masing masing adalah sebuah program kecil yang menerima inputan dari user melalui terminal. mereka mempunyai ciri ciri yaitu :</p><ul><li><strong>small &amp; lightweight</strong></li><li><strong>easy to use</strong></li><li><strong>specific</strong>, satu command hanya mengerjakan satu tugas spesifik</li><li><strong>integrated</strong>, dapat diintegrasikan dengan command yang lain melalui pipe dan redirection untuk mengerjakan rangkaian tugas</li></ul><pre>template : <br>command_1 | command_2 | command_3 | .... | command_N</pre><pre>contoh :<br>$ cat wisata.txt | grep &quot;malang&quot; | tee wisata-malang.txt | wc -l</pre><p>command diatas digunakan untuk melakukan operasi baca pada file wisata.txt, cari semua baris didalam file yang terdapat kata malang, kemudian masukkan hasilnya ke file wisata-malang.txt dan yang terakhir tulis jumlah baris yang terdapat kata malang ke terminal. dapat diketahui bahwa command <em>cat </em>khusus untuk melihat isi file, command <em>grep </em>untuk mencari pattern di sebuah file, command <em>tee</em> untuk menbaca dari standard input dan menulis ke standard output atau file, dan command <em>wc</em> untuk menghitung kata. hal yang membuat saya takjub adalah meskipun mereka (command line function) melakukan tugas yang sederhana &amp; spesifik namun mereka juga bisa diintegrasikan satu sama lain dengan hanya menggunakan simbol yang sederhana. sekarang pertanyaanya bagaimana cara menginterasikan service service yang ada didalam microservice ?</p><h3>Integrasi Antar Aplikasi / Service</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IZ8l5uHBnNT8PQYm68QFvw.png" /><figcaption>Gambar 2 : Ilustrasi sederhana integrasi arsitektur monolith &amp; microservice</figcaption></figure><p>kita bahas dulu mengenai integrasi, integrasi yang dimaksud disini adalah membuat beberapa aplikasi/service saling bekerja sama untuk mencapai satu tujuan besar. beberapa aplikasi dapat dikembangkan secara in-house dan sisanya dapat dikerjakan oleh vendor (ini biasanya terjadi di perusahaan). beberapa aplikasi mungkin perlu diintegrasikan meskipun pada awalnya tidak dirancang untuk diintegrasikan dengan aplikasi lain dan aplikasi tersebut tidak dapat diubah. lalu apa yang membuat integrasi aplikasi bisa dikatakan baik ? ada beberapa hal yang harus dipertimbangkan yaitu :</p><ul><li><strong>application integration — </strong>meskipun kita mengembangkan satu aplikasi yang pada awalnya tidak membutuhkan kerja sama dengan aplikasi lain. tetapi kita tetap harus memikirkan peluang terjadinya kolaborasi atau integrasi dengan aplikasi lain dimasa datang.</li><li><strong>application coupling —</strong> aplikasi yang terintegrasi harus meminimalkan ketergantungannya satu sama lain sehingga masing-masing aplikasi dapat berkembang tanpa menimbulkan masalah bagi yang lain (disarankan loosely coupled).</li><li><strong>integration simplicity — </strong>dalam proses mengintegrasikan aplikasi, semakin sederhana cara pengintegrasiannya semakin baik. saya analogikan seperti ini. kita mempunyai smartphone dan headset, kita ingin mendengarkan sebuah lagu menggunakan headset tersebut, namun sayangnya smartphone kita tidak mempunyai jack 3.5mm akibatnya harus mengeluarkan sejumlah uang untuk membeli sebuah converter USB type c to jack 3.5mm. sama seperti sebuah aplikasi, ketika kita ingin mengintegrasikannya dengan aplikasi lain apakah ada biaya yang kita keluarkan supaya saling terhubung misalnya mengupgrade spesifikasi cloud VM agar komunikasi antar aplikasi semakin lancar, mengganti protokol komunikasi, atau yang paling parah buat developer adalah mengubah atau menambahkan source code yang sudah ada agar integrasi dapat berjalan (karena perubahan tersebut berpotensi menimbukan masalah baru).</li><li><strong>integration technology — </strong>integrasi antar aplikasi mungkin membutuhkan hardware atau software (tools/library) khusus. software yang dipakai bisa saja mahal dan bersifat vendor lock-in. kemudian developer juga dituntut untuk mengerti cara penggunaan software tersebut untuk mengintegrasikan aplikasi.</li><li><strong>data format — </strong>aplikasi yang saling terintegrasi harus menyepakati format pertukaran data, jika format pertukaran data tidak bisa dicapai / disepakati, maka jalan tengahnya adalah menyediakan sebuah translator yang ditempatkan ditengah tengah untuk menjembatani pertukaran data, tentunya hal ini akan berimbas ke faktor data timeless.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FreiBUXZHFpqr6rnlf4QvA.png" /><figcaption>gambar 3. format data yang digunakan untuk integrasi aplikasi. semisal JSON dengan field yang telah ditentukan</figcaption></figure><ul><li><strong>data timeliness — </strong>dalam integrasi aplikasi kecepatan pertukaran data antar aplikasi perlu diperhatikan. semakin cepat semakin baik. karena jika ada aplikasi yang lambat dalam memproses data maka akan berimbas ke aplikasi yang lain. biasanya dalam prakteknya aplikasi tidak serta merta mengirim satu buah data begitu saja, namun terlebih dahulu dilihat apakah ukuran data yang dikirim masih dalam batas yang sesuai atau tidak, jika ukuran data yang dikirim sangat besar maka data tersebut akan di pecah pecah menjadi beberapa bagian (biasanya disebut chunk) sebelum akhirnya dikirim ke aplikasi/service yang dituju.</li><li><strong>data or functionality — </strong>dalam integrasi aplikasi biasanya ada 2 hal yang diinginkan yaitu share data atau share fungsionalitas.</li><li><strong>asynchronicity — </strong>pemilihan jenis komunikasi juga harus dipertimbangkan. pemilihan ini tergantung dari konteksnya. misal ada product service yang mempunyai dependensi ke order service. jenis komunikasi yang dipilih adalah synchronous karena product service membutuhkan balasan segera dari order service apakah order diterima atau tidak. kemudian contoh yang lain adalah misalkan ada billing service yang mempunyai dependency ke email service, jenis komunikasi yang dipilih adalah asynchronous karena billing service tidak peduli apakah nota pembelian sudah terkirim ke email penerima atau belum, pekerjaan tersebut sudah dihandle oleh email service. billing service akan tetap mengirim data ke email service walaupun email service agak sedikit lama dalam menyelesaikan saru tugas untuk mengirim email dan melaporkan hasilnya kembali ke billing service.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*23dbigPq8UfCsRuXz6uO-w.png" /><figcaption>Gambar 4 : Ilustrasi proses sinchronous &amp; asynchronous</figcaption></figure><h3><strong>4 Macam Cara Integrasi Aplikasi</strong></h3><p>secara umum terdapat 4 cara integrasi aplikasi, masing masing cara memiliki kelebihan dan kekurangannya masing masing</p><ol><li><strong>File Transfer</strong> — setiap aplikasi dapat membuat file yang dapat di consume oleh yang lain dan aplikasi tersebut juga dapat meng-consume file yang dibuat oleh aplikasi yang lain</li><li><strong>Shared Database</strong> — setiap aplikasi menyimpan data yang ingin dishare di satu database</li><li><strong>Remote Procedure Invocation</strong> — setiap aplikasi mengekspose procedure atau fungsi yang dapat dipanggil secara remote (istilah kerennya saat ini adalah REST API)</li><li><strong>Messaging </strong>— setiap aplikasi terhubung dengan messaging system, mereka bertukar data dan menjalankan behaviour melalui message.</li></ol><p>semakin kebawah urutannya semakin modern pula pendekatannya dan semakin efisien untuk menyelesaikan masalah integrasi yang semakin kompleks. lalu pertanyanaanya cara yang mana yang paling baik digunakan saat integrasi aplikasi ? jawabannya adalah tergantung situasi. kita sebaiknya tidak terpaku untuk selalu menggunakan satu cara integrasi namun sebagai gantinya kita dapat memilih cara yang lain tergantung dari perubahan didalam aplikasi kita. contohnya seperti gambar berikut</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L0jsbrYDAbZpOAjYpQyrCQ.png" /><figcaption>Gambar 5 : ilustrasi transformasi arsitektur aplikasi</figcaption></figure><p>arsitektur aplikasi yang dikembangkan mungkin dapat berubah seiring bertambahnya jumlah developer, kompleksitas aplikasi, dan faktor faktor yang lain, biasanya dalam mengembangkan aplikasi, developer akan memakai arsitektur monolith terlebih dahulu. aplikasi tersebut berisi seluruh komponen yang disusun dan digabungkan menjadi satu (tightly coupled) yang membentuk sebuah aplikasi besar (dan tunggal). agar fungsionalitas aplikasi tersebut dapat berjalan, semua komponen bekerja sama dengan cara memanggil fungsi yang terdapat di aplikasi tersebut.</p><p>kemudian ketika aplikasi tersebut beralih memakai arsitektur microservice (karena kebutuhan / alasan yang kuat), seluruh komponen yang awalnya membentuk satu aplikasi yang besar (dan tunggal), kemudian dipecah atau dibagi sesuai domainnya yang disebut sebagai <strong>service</strong>, setiap service mengerjakan tugas yang spesifik sesuai dengan domainnya masing masing. aplikasi monolith yang kita pecah sebelumnya harus kita satukan / integrasikan kembali untuk mendapatkan fungsionalitas yang sama dengan aplikasi sebelumnya yang menggunakan arsitektur monolith.</p><p>jika pada arsitektur monolith semua komponen dapat berkomunikasi dengan <strong>memanggil function / method</strong>, maka di arsitektur microservice, service service tersebut berkomunikasi via <strong>network</strong>. biasanya jika jumlah servicenya masih sedikit maka integrasi bisa menggunakan Remote Procedure Invocation. dalam arsitektur microservice cara ini tergolong masih bersifat tightly coupled. karena jika salah satu service mati maka service yang lainnya akan terganggu (tidak bisa berjalan sesuai yang diinginkan). jika servicenya sudah banyak, katakanlah puluhan service maka cara integrasi yang cocok adalah dengan menggunakan messaging. mengapa cocok? karena sekarang semua service tidak tergantung langsung ke service yang lain melainkan ke messaging system, jadi misalnya ketika service A ingin mengirim data ke service B maka data tersebut akan melewati messaging system tersebih dahulu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ia8GNe7-TzBmKyW6iPRroA.png" /><figcaption>Gambar 6 : Messaging System</figcaption></figure><p>mungkin pembaca mempunyai pertanyaan seperti ini, berarti data yang kita kirim memerlukan waktu yang lebih lama untuk sampai ke service tujuan? jawabannya iya, karena salah satu tujuan dari implementasi messaging system di arsitektur microservice adalah untuk availability dan extensibility service, dimana ketika ada salah satu service yang berjalan lambat maka service yang lain tidak akan terpengaruh dan ketika ada service baru yang ditambahkan maka service tersebut tinggal di “plug and play” ke messaging system.</p><p>perlu diketahui bersama bahwa jenis komunikasi yang dipakai jika mengimplementasikan messaging adalah jenis komunikasi yang bersifat asynchronous, jadi paradigma yang digunakan dalam membuat service akan berbeda dari sebelumnya, developer perlu mempelajari bagaimana membuat sebuah aplikasi yang berjalan secara asynchronous..beberapa messaging system yang penulis ketahui adalah apache kafka, apache rabbitMQ, IBM MQ, dan NATS.</p><h3><strong>Kesimpulan</strong></h3><p>cara integrasi aplikasi yang penulis sebutkan diatas mempunyai kelebihan dan kekurangannya masing masing. namun penulis tidak menjelaskan lebih detail apa saja kelebihan dan kekurangan dari masing masing cara tersebut. pemilihan cara integrasi sangat tergantung dari domain / masalah yang akan diselesaikan, maka dari itu kenali dulu domainnya dan coba pertimbangkan segala konsekuensi ketika memakai salah satu cara. akhir kata disini penulis hanya menjelaskan integrasi aplikasi secara umum. semoga artikel ini memberikan manfaat dan mohon maaf bila ada kekurangan.</p><h3><strong>Whats Next</strong></h3><p>pada artikel selanjutnya akan dibahas lebih detail mengenai messaging system, message pattern, message delivery guarantee, dan kendala kendala yang dihadapi saat implementasi messaging sebagai cara integrasi antar aplikasi.</p><p>Further Reading :</p><p><a href="https://martinfowler.com/articles/microservices.html">https://martinfowler.com/articles/microservices.html</a></p><p><a href="https://www.infoq.com/articles/lessons-learned-monolith-microservices/">https://www.infoq.com/articles/lessons-learned-monolith-microservices/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bdd5cfb21436" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Loki — Logging Aggregation System — Hands On]]></title>
            <link>https://ahmad-asrori.medium.com/loki-logging-aggregation-system-hands-on-f4c58340a49b?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4c58340a49b</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Tue, 22 Sep 2020 14:37:09 GMT</pubDate>
            <atom:updated>2020-09-25T08:07:30.579Z</atom:updated>
            <content:encoded><![CDATA[<h3>Loki — Logging Aggregation System — Hands On</h3><p>setelah memahami arsitektur dan workflow dari loki, saatnya melakukan hands on. skenario yang saya pakai seperti ini</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ymVF3ldOtikDfPGHoC0bXw.png" /><figcaption>skenario</figcaption></figure><p>diberikan 2 buah node, node pertama mempunyai IP 54.169.44.247 dan node kedua mempunyai IP 18.138.242.130. promtail ditempatkan di node pertama sedangkan grafana dan loki ditempatkan di node kedua, semua komponen (promtail, grafana, dan loki) dijalankan dengan docker. jadi bisa dipastikan semua node sudah terinstall docker sebelumnya.</p><h3><strong>Setup</strong></h3><p><strong>Node Pertama</strong></p><p>pull image promtail</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cWkRmyAZ50Mhcu-x0qLJug.png" /></figure><p><strong>Node Kedua</strong></p><p>pull image loki dan grafana</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Mi5RYC2EcQmcxciQOIOrQ.png" /></figure><p>buat folder baru, misal diberi nama <em>loki-poc, </em>kemudian buat file docker-compose.yaml dan loki.yaml didalam folder loki-poc</p><pre>$ mkdir loki-poc<br>$ cd loki-poc<br>~/loki-poc $ pwd<br>/home/ubuntu/loki-poc</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/237b710d28daf0b3797518e6191489b7/href">https://medium.com/media/237b710d28daf0b3797518e6191489b7/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a6d452aa7588a717c2b0d5d8db03dd43/href">https://medium.com/media/a6d452aa7588a717c2b0d5d8db03dd43/href</a></iframe><p>kemudian jalankan semua container dengan perintah berikut</p><pre>docker-compose up -d</pre><p>kemudian coba cek apakah grafana dashboard sudah bisa diakses melalui port 3000 dengan di IP node kedua</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*smqrRukDygQajYBM0KSB1g.png" /></figure><p>untuk masuk ke dashboard, default email dan password adalah admin. pembaca bisa menggantinya dengan password yang lain di konfigurasi nantinya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p9qd4Mrk0xLph_wq7_14aA.png" /><figcaption>halaman grafana dashboard</figcaption></figure><h3><strong>Case #1 : System Log</strong></h3><p>pada case pertama ini kita akan mempelajari bagaimana caranya meng-aggregasi system log yang berada di node pertama. linux memiliki direktori khusus untuk menyimpan log. biasanya log dari system dan berbagai aplikasi ditempatkan di direktori /var/log.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Q6TiWFOaNVMc04iYT2Ubw.png" /><figcaption>isi dari direktori /var/log</figcaption></figure><p>beberapa file yang harus di ambil lognya antara lain :</p><ul><li>/var/log/syslog : file yang berisi record semua aktivitas yang terjadi didalam sistem</li><li>/var/log/auth.log : file yang berisi record yang berkaitan dengan security seperti login, root user action, dan output dari PAM (pluggable authentication module)</li><li>/var/log/kern.log : file yang berisi record event, error, dan warning yang terjadi di kernel</li></ul><p><strong>implementasi</strong></p><p><strong>node pertama</strong></p><p>di bagian setup, kita sudah menjalankan grafana dan loki container di node kedua. namun di node pertama kita hanya mendownload image promtail. sekarang barulah kita manjalankan promtail di node pertama. perlu diketahui bersama promtail berfungsi untuk mengirim log stream ke loki dengan menspesifikasikan file file yang akan dilihat isinya.</p><p>buat folder baru, misal diberi nama promtail-poc</p><pre>$ mkdir promtail-poc<br>$ cd promtail-poc<br>~/promtail-poc $ pwd<br>/home/ubuntu/promtail-poc</pre><p>kemudian buat file yang bernama promtail.yaml didalam direktori tersebut dan isi dengan konfigurasi sebagai berikut</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5b712c5b6cdf41b0cdd564d21a783ee9/href">https://medium.com/media/5b712c5b6cdf41b0cdd564d21a783ee9/href</a></iframe><p>jangan lupa mengganti tulisan IP ADDRESS dengan IP node kedua.</p><p>blok server pada file konfigurasi diatas menspesifikasikan bagaimana behaviour promtail sebagai server. dalam artikel sebelumnya sudah dijelaskan bahwa setiap komponen loki mempunyai 2 server yaitu HTTP server dan gRPC server. nah karena promtail butuh berkomunikasi dengan loki yang berada di node berbeda maka yang kita set bisa http_listen_portnya saja. di file konfigurasinya saya set http_listen_portnya 9000, secara default http_listen_portnya di set ke 80 oleh promtail.</p><p>blok clients pada file konfigurasi diatas menspesifikasikan lokasi dimana loki berada agar promtail bisa melakukan push log stream. kita juga bisa menspesifikasikan interval waktu push log stream dan maksimum size log stream yang dikirim. bagaimana jika loki dilengkapi dengan authentication seperti basic auth ? jika bisa menspesifikasikan username dan password di blok ini juga.</p><p>block scrape config pada file konfigurasi diatas menspesifikasikan bagaimana promtail mengambil log dengan discovery method yang ditentukan. di bagian __path__ pada konfigurasi tersebut kita menspesifikasikan file file apa saja yang dipilih untuk dilihat isinya. dibagian tersebut saya isi dengan /var/log/*log dimana file yang mempunyai ekstensi .log dan file yang mempunyai nama akhiran log akan dilihat isinya.</p><p>langkah selanjutnya dalah menjalankan promtail. jalankan dengan perintah berikut :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U3rnUA5O-gScs5l0DIuulw.png" /></figure><p>kemudian cek apakah promtail sudah benar benar berjalan atau belum</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ar8PIUPVM_BzxsIue4z3Jw.png" /></figure><p><strong>node kedua</strong></p><p>buka grafana dashboard, klik menu configuration kemudian pilih data source, di halaman data source terdapat banyak pilihan integrasi aplikasi, pilih loki</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FBCAlzQUOXYVd01Q4VvMxA.png" /></figure><p>isi url dengan IP address node kedua karena loki dijakankan di node kedua</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0-VBfMkluYMllDU2Q9IxSg.png" /></figure><p>kemudian pada menu explore pilih jobname varlogs sehingga muncul tampilan log yang di push oleh promtail</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oldUbdmDtw3oDaIqaWhKig.png" /></figure><p>untuk memfilter log, kita bisa menggunakan logQL. logQL adalah query language sederhana yang dipakai oleh loki. misal kita menulis query</p><pre>{job=&quot;varlogs&quot;} |= &quot;ERROR&quot;</pre><p>maka loki akan mencari konten dari log stream yang mengandung kata ERROR</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0W42iZxvQOD4tRKJU3AiSA.png" /></figure><p>bahkan kita bisa melihat kejadian sebelum dan sesudah terjadinya error dengan mengklik tombil show more di baris log</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7a5rvPiIJBFJY35XDOpGaQ.png" /></figure><p>mari kita coba satu logQL lagi, misal kita ingin mengetahui rasio error yang terjadi dari waktu ke waktu</p><pre>rate({job=&quot;varlogs&quot;}[1m] |= &quot;ERROR&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XfXJwEaNoyIO4ZNwujjSCQ.png" /></figure><h3><strong>Case #2 : Docker Container</strong></h3><p>bagaimana jika ada aplikasi yang berjalan di docker container namun kita ingin mengambil log dari aplikasi tersebut, apakah kita bisa menggunakan cara yang sama seperti kasus pertama? jawabannya tidak, karena promtail didesain untuk mengambil local log saja. untuk mengambil log dari docker container kita harus mengganti log driver dari docker itu sendiri.</p><p>cara mengganti log driver bawaan docker dengan log driver dari loki dengan menggunakan perintah seperti ini</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1LSAVBXTCGSyV2xFhwxJMA.png" /></figure><blockquote>docker plugin masih belum disuppport di windows. lihat lebih lanjut <a href="https://docs.docker.com/engine/extend/">https://docs.docker.com/engine/extend/</a></blockquote><p>untuk mengujinya mari kita buat skenario lagi,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZdi61okAy708kpreFBqUg.png" /><figcaption>docker container skenario</figcaption></figure><p>semisal di node pertama ditambahkan aplikasi golang dan database mysql. katakanlah adalah sebuah aplikasi crud sederhana. kemudian aplikasi dan db tersebut dijalankan dengan docker. saya sudah mempersiapkan image dan file docker compose nya</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/824fc4034995e05b0df6cf4ba50af72b/href">https://medium.com/media/824fc4034995e05b0df6cf4ba50af72b/href</a></iframe><p>kemudian jalankan dengan perintah</p><pre>docker-compose up -d</pre><p>dan saya melakukan beberapa operasi crud ke aplikasi</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k_uVLLTHbq_jF4b1mrOjxw.png" /><figcaption>golang logs</figcaption></figure><p>sekarang mari kita cek grafana dashboard</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iDZEwENkbfzQYGrD9cYKlw.png" /><figcaption>log service golang</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kzvQTdu3n2jDEndVupbj6w.png" /><figcaption>log service mysql</figcaption></figure><p>terlihat bahwa log sudah berhasil di push ke loki, cara ini mempunyai kelebihan menurut saya yaitu</p><ul><li>log mudah diproduksi karena aplikasi hanya perlu menampilkan log di console / terminal</li><li>tidak membebani kinerja aplikasi (aplikasi tidak perlu menulis log ke file saat sedang berjalan)</li><li>inter-service correlation, kita mendapatkan log semua service yang berjalan dalam satu time series jika service service tersebut dijalankan dengan docker compose</li></ul><h3><strong>Case #3 : Legacy App</strong></h3><p>bagaimana jika terdapat sebuah kasus dimana ada sebuah legacy app yang rencananya mau dijalankan dengan docker, dalam urusan logging aplikasi tersebut masih menulis log ke file.</p><p>dialog imajiner</p><blockquote>Q : apakah bisa menggunakan solusi pada kasus kedua ?</blockquote><blockquote>A : tergantung situasi. jika menggunakan solusi seperti pada kasus kedua maka harus siap untuk mengubah source code dari aplikasi kita.</blockquote><blockquote>Q : apakah ada solusi yang lain tanpa mengubah source code ?</blockquote><blockquote>A : ada, daripada menghabiskan waktu untuk me-rewrite source code, lebih baik memanfaatkan promtail untuk mem-push log stream dari file.</blockquote><blockquote>Q : bukankah promtail hanya dapat digunakan untuk melalukan log stream local file saja, sedangkan jika aplikasi yang kita jalankan berada di docker container, log file yang ditulis oleh aplikasi kita tidak dapat diakses dari luar container?</blockquote><blockquote>A : kita bisa memanfaatkan bind volume pada docker agar log file tersebut dapat diakses dari luar container.</blockquote><blockquote>Q : bagaimana kalau setiap container kita sertakan promtail?</blockquote><blockquote>A : sebaiknya jangan, karena jika docker image yang digunakan berbeda beda maka konfigurasinya juga beragam. sebaiknya promtail hanya diinstall satu buah per node.</blockquote><p><strong>implementasi</strong></p><p>saya sudah membuat docker image, dimana docker image tersebut adalah aplikasi yang sama seperti kasus nomor 2, namun perbedaanya adalah daripada saya menampilkan log ke console / terminal, saya alihkan log tersebut ke file agar sesuai dengan kasus ini.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/16d9f963adc0846ac1b6101ece686432/href">https://medium.com/media/16d9f963adc0846ac1b6101ece686432/href</a></iframe><p>yang perlu diperhatikan adalah ketika aplikasi dijalankan dengan docker, kita harus tahu letak dimana log file tersebut berada (absolute path dari log file yang berada didalam docker container). setelah mengerahui absolute pathnya, kita buat direktori mirroring / direktori bayangan dari file tersebut di local system. tujuaanya agar lebih mudah diingat saja.</p><p>misal ketika container app-golang dijalankan, aplikasi yang berada di dalam container tersebut membuat log file yang diberi nama app.log yang ditempatkan di direktori /go. maka kita juga harus membuat direktori /go di local system kita dengan file app.go yang berada di direktori tersebut.</p><p>setelah container app-golang berhasil dijalankan, saya lakukan beberapa crud operasi ke aplikasi. dan kemudian melihat file app.log yang berada di local system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-sOv6TdUdpLVG9yhsixrqw.png" /></figure><p>kemudian tambahkan job ke promtail</p><pre>server:<br>  http_listen_port: 9080</pre><pre>positions:<br>  filename: /tmp/positions.yaml</pre><pre>clients:<br>  - url: <a href="http://54.169.44.247:3100/loki/api/v1/push">http://[IP_ADDRESS/DOMAIN]:3100/loki/api/v1/push</a></pre><pre>scrape_configs:<br>- job_name: system<br>  static_configs:<br>  - targets:<br>      - localhost<br>    labels:<br>      job: varlogs<br>      __path__: /var/log/*log<br>- job_name: app<br>  static_configs:<br>  - targets:<br>      - localhost<br>    labels:<br>      job: applogs<br>      __path__: /go/app.log</pre><p>dan membinding direktori /go yang berada di local filesystem ke promtail container</p><pre>$ docker run -d -v $(pwd):/mnt/config -v /var/log:/var/log -v /go:/go grafana/promtail -config.file=promtail.yaml</pre><p>kira kira ilustrasinya seperti ini</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*X9dvTt6EOUzpDFnLfHJUnA.png" /></figure><p>setelah menjalankan promtail container, sekarang saatnya kita lanjut menuju grafana dashboard untuk melihat hasilnya</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p-jcJ7e_1UZn5IZyl7dc_g.png" /></figure><p>dapat dilihat bahwa log yang berada di file app.log sudah bisa di ambil oleh loki. pada kasus ketiga ini saya memakai skenario bind volume. tetapi saya rasa masih ada skenario yang lain yang bisa dicoba semisal seperti container share volume. namun karena keterbatasan waktu, saya akan coba di lain waktu.</p><h3><strong>Case #4 : Job</strong></h3><p>service / aplikasi tidak selalu berjalan terus menerus. ada juga kebutuhan service hanya dijalankan sekali untuk melakukan tugas, dan ketika selesai melakukan tugas service tersebut lalu berhenti. bisa jadi job hanya berjalan hanya 1 detik dan kemudian berhenti. kita tidak tahu apakah dia sudah mengerjakan tugas atau malah error. kita memerlukan log dari job tersebut untuk mengetahui leboh dalam. dengan log driver dari loki kita dapat mengatur seberapa cepat batch log stream yang mau dikirim ke loki.</p><pre>version: &quot;3.7&quot;<br>services:<br>  logger:<br>    image: image/job<br>    logging:<br>      driver: loki<br>      options:<br>        loki-url: &quot;http://[IP_ADDRESS/DOMAIN]:3100/loki/api/v1/push&quot;<br>        loki-retries: 10<br>        loki-batch-wait: 1s</pre><p>diatas adalah contoh konfigurasi yang bisa digunakan untuk job, loki-retries adalah berapa banyak log line yang dikirim dalam satu batch. sedangkan loki-batch-wait adalah interval waktu yang digunakan oleh docker driver untuk mengirim satu batch secara penuh maupun tidak ke loki. pembaca bisa mengatur kembali konfigurasi tersebut.</p><h3><strong>Kesimpulan</strong></h3><p>loki merupakan logging aggregation system yang powerfull karena dia sudah dirancang untuk dapat berjalan di 2 mode yaitu monolithic dan microservice. dalam praktek yang telah dikerjakan sebelumnya loki berjalan di monolithic mode dengan berbagai case yang ditemui oleh penulis. loki meskipun dalam prakteknya terlihat biasa saja namun jika melihat arsitektektur dan cara kerjanya mungkin akan terlihat kerumitannya.</p><p>dalam artikel sebelumnya yang membahas mengenai arsitektur dan workflow dari loki. saya menjelaskan mengenai konsep ingester, distributor, querier dan storage. pada praktek kali sedikit sekali menemukan hal hal yang berkaitan dengan konsep konsep tersebut. kita lebih banyak bermain dengan promtail yang tugasnya adalah untuk mengirim log stream ke logging aggregation system.</p><p>masih ada fitur yang belum saya dalami yaitu logQL. logQL adalah query language yang digunakan oleh loki. logQL memberikan kemampuan kepada kita untuk melakukan selection, filtering dan melakukan kalkulasi terhadap log. fitur selanjutnya adalah alerting dimana dia dapat memberikan kemampuan kepada kita untuk melakukan query secara berkala untuk mengecek suatu kondisi, apabila kondisi tersebut memenuhi maka alerting akan memberikan notifikasi kepada kita. misal alerting untuk memberi notifikasi kepada kita jika ada service yang mengeluarkan error sebanyak 100 kali dalam kurun waktu 1 menit terakhit.</p><h3><strong>Whats Next</strong></h3><p>pada praktek kali ini, data log stream disimpan di local filesystem, hal ini tentu tidak scalable jika ukuran volume dari node tidak banyak. oleh karena itu pada artikel berikutnya akan dilanjutkan dengan mengintegrasikan loki dengan layanan storage dari AWS yaitu AWS S3 untuk menyimpan chunk dan AWS DynamoDB untuk menyimpan index</p><p>docker image resource :</p><p><a href="https://hub.docker.com/u/asrori08">https://hub.docker.com/u/asrori08</a></p><p>referensi :</p><p><a href="https://grafana.com/docs/loki/latest/">https://grafana.com/docs/loki/latest</a>, diakses 21 september 2020</p><p><a href="https://docs.docker.com/">https://docs.docker.com</a>, diakses 21 september 2020</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4c58340a49b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logging Aggregation System with Loki — arsitektur dan workflow]]></title>
            <link>https://ahmad-asrori.medium.com/logging-aggregation-system-with-loki-arsitektur-dan-workflow-135e56080cae?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/135e56080cae</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Mon, 21 Sep 2020 16:49:10 GMT</pubDate>
            <atom:updated>2020-09-22T01:40:04.406Z</atom:updated>
            <content:encoded><![CDATA[<h3>Loki — Logging Aggregation System — Arsitektur dan Workflow</h3><p>Logging sebenarnya adalah melihat sekumpulan event dan mencatat beberapa konteks untuk masing-masing event. Misalnya, melihat semua HTTP Request yang masuk, atau semua database transaction. namun kita juga harus membatasi jumlah event yang akan dicatat kalau tidak maka akan menghabiskan banyak resource (storage dan bandwidth).</p><p>loki merupakan sebuah logging aggregation system. loki jika saya jelaskan secara sederhana adalah sebuah sistem yang mengumpulkan log dari berbagai tempat yang nantinya log log tersebut disimpan di local storage atau bisa juga di object storage semacam AWS S3.</p><h3><strong>Operational Mode</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*jk_yg-hNLijYR9yP9OqJQw.png" /><figcaption>Mode Operasional</figcaption></figure><p>Loki memiliki seperangkat komponen yang disebut sebagai modul. Setiap komponen memiliki 2 server yaitu</p><ol><li>gRPC server untuk internal traffic</li><li>HTTP server untuk eksternal API request dan mengekspos URL endpoint readiness, health, dan metrics.</li></ol><p>Komponen mana yang dijalankan Loki ditentukan oleh flag -target di baris perintah atau bagian target: &lt;string&gt; di file konfigurasi Loki. Jika nilai targetnya di-set ke all, Loki akan menjalankan semua komponennya dalam satu proses yang sebagai “single process”, “single binary”, atau monolithic mode. monolithic mode adalah default deployment dari Loki ketika Loki diinstall menggunakan Helm.</p><p>Jika nilai target tidak di-set ke all (yaitu, disetel ke querier, ingester, query-frontend, atau distributor), Loki berjalan dalam mode “horizontal scalable”, atau microservices mode.</p><p>Setiap komponen Loki, seperti ingester dan distributor, berkomunikasi satu sama lain melalui gRPC menggunakan gRPC listen port yang ditentukan dalam konfigurasi Loki. Saat menjalankan komponen dalam monolithic mode, setiap komponen meskipun berjalan dalam single process, semua komponen akan terhubung satu sama lain melalui local network untuk saling berkomunikasi.</p><h3>Arsitektur Loki</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rUSZUiixsr2iAmj77vFuEg.png" /><figcaption>Komponen Komponen Loki</figcaption></figure><p><strong>Distributor</strong></p><p>komponen distributor mempunyai tugas untuk menangani log stream yang masuk dari promtail. distributor adalah tempat pemberhentian pertama untuk menulis data log. Setelah distributor menerima log stream setiap log stream divalidasi kebenarannya dan untuk memastikan bahwa log stream tersebut berada dalam limit sudah ditentukan. Potongan log stream yang valid kemudian dibagi menjadi beberapa bagian yang disebut sebagai <strong>chunk</strong> dan dikirim ke beberapa ingester secara paralel.</p><p><strong>Ingester</strong></p><p>komponen ingester bertugas untuk membangun chunks dan menyimpannya ke storage (DynamoDB, S3, Cassandra, dll.) di jalur tulis dan mengembalikan data log untuk query di in-memory di jalur baca.</p><p><strong>Querier</strong></p><p>komponen querier bertugas untuk menangani query yang menggunakan query language LogQL, mengambil log dari ingester dan backend storage.</p><h3><strong>Write Path Workflow (memproses log yang masuk)</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-FPTrxsG_CUCTh2QGADhaw.png" /><figcaption>Jalur Tulis</figcaption></figure><p>Distributor menerima log stream dari client (promail, fuentd, docker driver), log sream mempunyai anatomi sebagai berikut :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QcVg8yYvilF2OnsIvJIbrA.png" /></figure><p>dapat dilihat bahwa log stream memiliki 3 bagian yaitu timestamp, label, dan konten. kemudian log stream dihash dan direplikasi terlebih dahulu sebelum dikirim ke ingester secara paralel. ketika log stream sampai di ingester, setiap ingester akan membuat <strong>chunk</strong> atau menambahkan chunk ke existing chunk. setiap chunk itu unik <strong>per-tenant</strong> atau <strong>per label</strong>. setiap chunk bersisi <strong>kumpulan log stream per-tenant atau per label dari waktu ke waktu</strong>. dalam artikel ini waktu dilambangkan dengan variabel T.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fotdhAs1xXG-OebJAOvhhg.png" /><figcaption>chunk</figcaption></figure><p>mungkin pembaca mempunyai pertanyaan seperti ini, seperti apa isi dari sebuah chunk? isinya kurang lebih seperti yang terlihat di gambar ini.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TCMhYPrW6sy8jeZZXcvSuQ.png" /><figcaption>ilustrasi isi dari chunk #1</figcaption></figure><p>dapat dilihat bahwa setiap chunk berisi timestamp dan log content dari suatu service yang kita ambil data lognya. sebenarnya pada saat implementasinya nanti, <strong>chunk berisi data yang sudah dalam keadaan ter-compress oleh ingester</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KFnucdSWLcULj_VlKMSILA.png" /><figcaption>isi dari chunk yang sudah di-compress</figcaption></figure><p>saat mencapai batas yang ditentukan (max chunk size atau idle time), chunk akan di simpan di storage. jika belum mencapai batas maka chunk masih berada di ingester (ingester menyimpannya di in-memory storage). jadi dapat dikatakan bahwa <strong>ingester menyimpan log stream terbaru, sedangkan storage menyimpan histori log stream.</strong></p><p>selain dapat disimpan di (monolithic mode), chunk dapat disimpan di object storage seperti AWS S3, Cassandra, dan GCS. mungkin bagi pembaca akan muncul pertanyaan baru, di gambar arsitektur loki diatas storage menyimpan chunk dan index, lalu apa itu index ? dan apa fungsinya ? index adalah file yang berisi lokasi dimana chunk berada. fungsinya adalah untuk mempercepat proses pencarian data log stream saat melakukan query.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GL3ePnIQnpp-XPLeCLW9uA.png" /><figcaption>ilustrasi dari index</figcaption></figure><p><strong>deep dive process between distributor and ingester</strong></p><p>selain menerima log stream dari client, distributor juga mempunyai tugas yaitu melakukan <strong>hashing and sharding.</strong> hashing and sharding adalah melakukan hash terhadap log stream (per label) yang masuk dan mengirim log stream yang sudah di hash tersebut ke ingester yang dipilih.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eTcCCxXycUEJ8BlOpE97HA.png" /></figure><p>Q : bagaimana jika ada ingester yang tidak berfungsi?</p><p>A : log stream akan gagal hilang karena tidak berhasil dikirim ke ingester yang dipilih.</p><p>Q : jika log stream berhasil di kirim ke ingester, lalu kemudian ingester tersebut tidak berfungsi apakah log stream akan hilang?</p><p>A : iya, karena ingester menyimpan data di in-memory, jadi sebelum sampai di storage, data log stream tidak benar benar persistence dan aman.</p><p>Q : lalu bagaimana solusinya agar data log stream tidak hilang?</p><p>A : dengan melakukan konfigurasi <strong>replikasi</strong> terhadap log stream di file konfigurasi (biasanya sudah diset secara default sebanyak 3 replikasi)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KrGfJOHAel-5609wEcesjQ.png" /></figure><p>jadi jika ada ingester yang tidak berfungsi log stream masih bisa diakses di ingester yang masih berfungsi karena distributor melakukan replikasi log stream sebanyak 3 kali dan semua replikasinya dikirim ke 3 ingester.</p><h3><strong>Read Path Workflow (memproses query)</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ki4QgNviLSd0w004FFEDsA.png" /></figure><p>Querier menerima HTTP Request untuk query yang masuk. kemudian querier meneruskan query ke semua ingester untuk mendapatkan log stream yang tersimpan di in-memory. ingester menerima permintaan baca dari queriesr dan mengembalikan log stream yang cocok dengan query, jika ada. jika tidak ada log stream yang dikembalikan dari ingester, maka querier akan meminta storage untuk mencari log stream.</p><p>setelah mendapatkan log stream yang sesuai dengan query, Querier melakukan iterasi atas semua data yang diterima, menduplikasi data tersebut, dan mengembalikan log stream melalui HTTP Response.</p><p>referensi :</p><p><a href="https://grafana.com/docs/loki/latest/architecture/">https://grafana.com/docs/loki/latest/architecture</a>, diakses 20 september 2020</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=135e56080cae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Memahami Arsitektur Prometheus]]></title>
            <link>https://ahmad-asrori.medium.com/memahami-arsitektur-prometheus-b0b7bb7003b3?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0b7bb7003b3</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Sun, 20 Sep 2020 14:27:04 GMT</pubDate>
            <atom:updated>2020-09-22T01:41:44.845Z</atom:updated>
            <content:encoded><![CDATA[<h3>Prometheus — Infrastructure and Service Monitoring System — Arsitektur dan Workflow</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1016/1*kH3qWn2IzPJPMe_YsdspAA.jpeg" /><figcaption>source : <a href="https://static.vecteezy.com/system/resources/previews/000/683/115/non_2x/learning-illustration-and-workflow-flat-line-design-infographic-with-blue-color.jpg">https://static.vecteezy.com/system/resources/previews/000/683/115/non_2x/learning-illustration-and-workflow-flat-line-design-infographic-with-blue-color.jpg</a></figcaption></figure><p>prometheus adalah sebuah monitoring dan alerting system yang saat ini banyak dipakai. prometheus termasuk kedalam metrics base monitoring yang dimana prometheus menggunakan model pull metrics. model ini mempunyai kelebihan yaitu tidak membebani service yang berjalan.</p><h3><strong>Komponen Komponen Arsitektur Prometheus</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ktoezmb8yB1wTCukb53X0w.png" /></figure><p><strong>Node : </strong>bare metal machine atau cloud VM yang mempunyai block storage berjenis HDD/SSD, tempat dimana prometheus server dideploy</p><p><strong>Service Discovery</strong> : tempat dimana daftar semua target/aplikasi yang ingin di monitoring disimpan.</p><p><strong>Prometheus Server</strong></p><ul><li>Retrieval : bertugas melakukan pull metrics dari jobs/exporter dan push gateway.</li><li>TSDB : sebuah time series database digunakan untuk menyimpan metrics</li><li>HTTP Server : sebuah web server yang digunakan menerima query melalui HTTP request</li></ul><p><strong>Prometheus Target</strong></p><ul><li>Jobs/Exporter : bisa berupa aplikasi yang kita buat atau third party application yang dideploy bersamaan dengan service untuk mengekspose metrics.</li><li>Short Lived Job : service kita yang dijalankan untuk melakukan tugas tugas yang sifatnya sekali jalan dan kemudian ketika tugasnya selesai maka dia berhenti. seperti service yang berjalan untuk melakukan backup data setiap hari pada jam sekian, service untuk melakukan migrasi data. dll</li></ul><p><strong>Push Gateway : </strong>tempat untuk menyimpan metrics dari short lived job.</p><p><strong>Alert Manager : </strong>penerima alert atau message dari prometheus server yang akan diubah menjadi notification untuk diteruskan ke channel selection (email, pager duty, dll)</p><p><strong>Data VIsualization</strong></p><ul><li>Prometheus Web UI : sebuah dashboard sederhana yang disediakan oleh prometheus untuk mengecek service yang dimonitoring dan melakukan data visualization</li><li>Grafana : aplikasi dashboard yang menawarkan tampilan yang lebih baik dan dapat diintegrasikan dengan berbagai platform lain dalam hal data visualization</li></ul><h3><strong>Konsep dan Workflow Monitoring Menggunakan Prometheus</strong></h3><p><strong>Find Service Location</strong></p><p>untuk melakukan monitoring terhadap suatu service, prometheus terlebih dahulu harus mengetahui lokasi dimana service tersebut berada. jika servicenya berada dalam kubernetes cluster maka kita dapat menggunakan discovery service. ada 5 tipe discovery service yang dapat digunakan di kubernetes yaitu <strong>node</strong>, <strong>pod</strong>, <strong>service</strong>, <strong>endpoint</strong>, dan <strong>ingress</strong>. cara ini biasanya digunakan jika arsitektur yang dipakai adalah arsitektur microservice. jika arsitektur yang dipakai adalah arsitektur monolithic maka kita cukup mendefinisikan lokasi service di <strong>local file configuration</strong>.</p><p>setelah semua lokasi target diketahui oleh prometheus, prometheus akan mengirimkan HTTP request ke semua service tersebut untuk mengecek status dari service tersebut apakah up atau down, jika status dari service tersebut up maka prometheus akan mulai melakukan pull metrics dari service tersebut dengan interval waktu yang telah ditentukan. jika status dari service tersebut down kita dapat melakukan konfigurasi agar prometheus dapat mengirim notifikasi ke pagerduty atau email kita melalui alert manager.</p><p><strong>Pull Metrics</strong></p><p>proses yang paling esensial dari monitoring menggunakan prometheus adalah proses pull metrics. pull metrics disini sebenarnya proses dimana prometheus server mengirim HTTP request ke service untuk mendapatkan metrics. metrics adalah informasi seputar event yang terjadi di dalam service. contoh metrics yang di pull oleh prometheus :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/588/1*R0R-wNIsEY9lKnNGN_5aPg.png" /></figure><p>metrics diatas dapat diartikan ada total 7 request yang masuk ke url / dan seterusnya. dapat dilihat bersama bahwa metrics tersusun dari 2 buah bagian yaitu <strong>event</strong> dan <strong>value / nilai</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0N8oYqhd5vz6L-MgKHP3AQ.png" /></figure><p>mungkin pembaca mempunyai pertanyaan seperti ini, metrics tersebut berasal dari mana ? metrics tersebut kita buat sendiri atau menggunakan exporter yang sudah ada. exporter adalah aplikasi kecil yang dideploy di tempat yang ingin dimonitoring.</p><p><strong>Save Metrics in Time Series Database</strong></p><p>setelah mendapatkan metrics dari service, metrics tersebut disimpan didalam database yang bernama TSDB (Time Series Database). karena database yang dipakai adalah database time series tentunya format data yang disimpan agak berbeda dengan format data yang biasa kita temui di database relasional. format data yang disimpan berbentuk seperti ini :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*El7-UMQaYwUuDpt_0uQX-g.png" /></figure><p>format data pada gambar diatas disebut sebagai data point atau sample. sample terdiri dari 3 bagian yaitu identifier, variabel t adalah timestamp, dan variabel v adalah value. identifier adalah <strong>event</strong>, t adalah <strong>unix timestamp</strong>. unix timestamp adalah jumlah detik yang dihitung dari epoch / tanggal 1 januari 1970 sampai pada waktu tertentu, sedangkan v adalah <strong>value / nilai</strong>.</p><p><strong>Query</strong></p><p>seperti database relasional, untuk mengolah data di database perlu dilakukan query. karena database yang dipakai adalah tsdb maka kita perlu mengetahui query language yang dipakai oleh database tersebut. tsdb menggunakan query language yang bernama <strong>promQL</strong>. promQL sama sekali tidak ada hubungannya dengan SQL namun promQL menggunakan sintaks yang lebih sederhana jika dibandingkan dengan SQL. contoh sedikit sintaks promQL :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zIWVkhXEuNSYgzdCmlRaqw.png" /><figcaption>query yang digunakan untuk mendapatkan rasio request yang error dari semua service</figcaption></figure><p><strong>Data Visualization</strong></p><p>sekarang pertanyaannya dimanakah kita dapat melakukan query? ada 3 opsi. yaitu menggunakan api client, prometheus web UI, atau grafana. biasanya kebanyakan orang akan menggunakan grafana. grafana adalah aplikasi untuk memvisualisasi dan menganalisa data. grafana dapat melakukan query, visualisasi dan eksplorasi terhadap metrics.</p><p>mungkin akan muncul pertanyaan berarti prometheus dan grafana adalah 2 buah aplikasi yang berbeda ? jawabannya iya. lalu bagaimana grafana dapat melakukan query ? kita dapat memasukkan lokasi dimana prometheus server berada. nantinya grafana akan mengecek terlebih dahulu apakah prometheus server statusnya available atau tidak, jika statusnya available maka kita dapat melakukan query. query akan dikirimkan dari grafana ke prometheus server melalui protokol HTTP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8uzio48G9CSCjXlkURtr_g.png" /><figcaption>melakukan query di grafana (source : <a href="https://www.openlogic.com/sites/openlogic/files/image/2019-07/visual_18.png">https://www.openlogic.com/sites/openlogic/files/image/2019-07/visual_18.png</a>)</figcaption></figure><p>hal yang paling diperlukan saat melakukan monitoring menggunakan prometheus adalah penguasaan materi mengenai promQL. dengan mempelajarinya kita dapat mendapatkan insight yang lebih mendalam menganai behaviour dari sistem yang kita kelola. promQL dirancang dengan sintaks query yang sederhana sehingga tidak membutuhkan learning curve yang dalam seperti SQL. di artikel berikutnya kita akan mencoba melakukan sebuah hands on agar konsep monitoring yang telah dipelajari sebelumnya semakin jelas.</p><p>referensi :</p><p><a href="https://prometheus.io/docs/introduction/overview/">https://prometheus.io/docs/introduction/overview</a>, diakses 20 september 2020</p><p>Brian Brazil, Prometheus : Up and Running, O’Reilly, 2018</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0b7bb7003b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Infrastructure and Service Monitoring at 20.000 feet]]></title>
            <link>https://ahmad-asrori.medium.com/infrastructure-and-service-monitoring-at-20-000-feet-78e1b76ecbac?source=rss-4cee03937f4e------2</link>
            <guid isPermaLink="false">https://medium.com/p/78e1b76ecbac</guid>
            <dc:creator><![CDATA[ahmad asrori]]></dc:creator>
            <pubDate>Sun, 20 Sep 2020 13:08:56 GMT</pubDate>
            <atom:updated>2020-09-25T07:36:55.481Z</atom:updated>
            <content:encoded><![CDATA[<h3>Monitoring at 20.000 feet</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x4vbUHv1njGYqVB_1O4Ipg.jpeg" /></figure><h3><strong>Intro</strong></h3><p>kita semua mengetahui bahwa penggunaan layanan berbasis IT dapat dengan mudah ditemui disekitar kita. contohnya seperti mengirim email, membeli barang di toko online, mengupload foto di instagram, menonton video di youtube, dll. ketika pembaca melakukan aktivitas aktivitas tersebut sebenarnya terdapat sebuah sistem yang bekerja di belakangnya untuk melayani permintaan penggunanya dan sebuah sistem dapat berjalan karena ditopang oleh sebuah infrastruktur yang berada dibawahnya.</p><p>jika kita sedang mengembangkan atau mengelola sebuah layanan dan infrastruktur IT baik secara fisik maupun non fisik (cloud) maka kita perlu memastikan bahwa layanan yang berjalan di atasnya dapat diakses oleh pengguna, cepat dalam merespon permintaan, dan menyajikan hasil yang sesuai dengan harapan. tidak hanya itu, kita juga perlu memastikan bahwa penggunaan resource oleh service yang berjalan harus efisien seperti jumlah kapasitas RAM harus diperhitungkan, membatasi outbound traffic sekian terabyte per bulan agar tidak terkena cost tambahan dari cloud provider, dll.</p><h3><strong>kendala yang dihadapi</strong></h3><p>selain memastikan hal hal diatas berjalan sesuai semestinya, kita pastinya akan dihadapkan kepada suatu permasalahan yang akan muncul didalam mengelola sebuah infrastruktur dan layanan seperti :</p><ol><li>Disk Full, sehingga tidak ada ruang untuk menyimpan data.</li><li>Software Bug, sehingga pengguna tidak mendapatkan apa yang diminta / request error.</li><li>High Temperature, sehingga menyebabkan hardware cepat rusak.</li><li>Network Outage, sehingga service tidak dapat berkomunikasi dengan service lain.</li><li>Low Memory Utilization, artinya ukuran memori terlalu besar sedangkan service tidak membutuhkan penggunaan memory yang tidak banyak.</li></ol><h3><strong>Esensi Monitoring</strong></h3><p>oleh karena itu diperlukan monitoring terhadap layanan dan infrastuktur yang kita miliki sehingga kita memiliki insight terhadap apa yang terjadi didalamnya dan apabila timbul masalah di kemudian hari kita bisa bertindak berdasarkan apa yang kita peroleh dari kegiatan monitoring. dalam dunia cloud computing, istilah monitoring akan sering kita temui, istilah observability juga akan sering kita temui namun istilah ini mengandung makna yang sama dengan istilah monitoring. jadi tidak perlu bingung dengan kedua istilah ini.</p><p>pada akhirnya sebagian besar kegiatan monitoring berfokus pada satu hal yaitu event tracking. event dapat meliputi apa saja termasuk :</p><ul><li>menerima HTTP Request</li><li>mengirim HTTP 400 Response</li><li>user melakukan login</li><li>menulis data ke disk</li><li>request memory ke kernel</li></ul><p>semua event dapat memiliki <strong>konteks</strong>. contohnya sebuah HTTP Request dapat mempunyai IP Address asal dan tujuan, URL yang di request, cookie yang di set, body request, dan user yang membuat request tersebut. sebuah HTTP Response dapat mempunyai HTTP status code dan body response. semakin lengkap konteks yang dapat dimonitoring semakin mempermudah memahami dan men-debug sistem (infrastructure and service) secara keseluruhan.</p><h3><strong>TIpe Tipe Monitoring</strong></h3><p>monitoring memiliki 4 tipe, setiap tipe memiliki kelebihan dan kekurangannya masing masing.</p><p><strong>Check Base Monitoring </strong>: check base monitoring adalah tipe yang monitoring yang paling sederhana. contohnya sebuah sistem memiliki satu webserver, satu database dan satu aplikasi. monitoring tools akan mengecek secara periodik kondisi dari masing masing service tersebut. apakah webserver berjalan, apakah database berjalan dan seterusnya. pengelola sistem dapat mengecek statusnya apakah status dari masing masing service tersebut ok, warning atau critical.</p><p>Kelebihan :</p><ul><li>tidak ada, tetapi lebih baik diimplementasikan daripada tidak. walaupun hanya sebatas mengecek kondisi suatu komponen atau service berjalan dengan baik atau tidak.</li></ul><p>kekurangan :</p><ul><li>fokus kearah blackbox monitoring. blackbox monitoring adalah monitoring yang dikhususkan kearah komponen infrastruktur (CPU usage, memory, load average).</li><li>lemah dalam menyajikan histori konteks dan konteks secara global.</li><li>sangat lemah jika diimplementasikan di environment yang kompleks seperti kubernetes karena tidak bisa memahami workload scheduling and shifting yang terjadi di didalam cluster.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G1awI6jDNkU3JRUet1JVfg.png" /><figcaption>Nagios</figcaption></figure><p><strong>Metrics : </strong>Metrics adalah tipe monitoring yang paling banyak digunakan untuk monitoring infrastruktur. metrics memberikan informasi mengenai perubahan nilai setiap saat terhadap suatu komponen (CPU, RAM, Disk) atau service (application) contoh : prometheus. influxdb, openTSDB.</p><p>kelebihan :</p><ul><li>murah dan mudah dibuat (metricsnya), service hanya perlu mencatat perubahan nilai dari konteks dan mengeksposenya keluar menggunakan endpoint.</li><li>sangat baik dalam melakukan aggregasi kondisi kesehatan infrastuktur.</li></ul><p>kekurangan :</p><ul><li>kurang detail untuk debugging, maksudnya adalah jika terjadi masalah kita tidak bisa mengetahui apa yang menyebabkan masalah tersebut muncul. karena metrics monitoring hanya mencatat perubahan nilai dari konteks. untuk itu diperlukan logging sebagai pelengkap.</li><li>lemah dalam menghubungkan metrics yang tercatat di service yang berbeda (inter-service correlation lack).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Az3Pv7nU7BPVivC6m7Kg8Q.png" /><figcaption>Promtheus + Grafana</figcaption></figure><p><strong>Logging : </strong>Logging adalah tipe monitoring yang lebih condong melihat event secara terbatas dan mencatat beberapa konteks untuk setiap event yang terjadi. untuk pembahasan mendetail mengenai logging akan dibahas di materi yang berbeda. contoh : ELK stack, loki.</p><p>kelebihan :</p><ul><li>sangat detail dalam debugging (tergantung seberapa banyak konteks yang dicatat).</li><li>mudah untuk dibuat (log dari sistem atau service, developer biasanya membuatnya).</li></ul><p>kekurangan :</p><ul><li>jika salah diimplementasikan maka berpotensi dapat membebani sistem atau service yang berjalan. contoh seperti mencatat log request yang masuk, jika request yang masuk 10–100 per menit mungkin tidak masalah, namun jika diatas 10.000 request permenit bakalan menjadikan masalah.</li><li>lemah dalam menghubungkan log yang tercatat di service yang berbeda (inter-service correlation lack).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uqi_O-CdwghWdG4XnvvJDA.png" /><figcaption>ELK stack</figcaption></figure><p><strong>Request Tracing : </strong>Request Tracing adalah tipe monitoring yang paling susah untuk diimplementasikan karena membutuhkan koordinasi dari setiap service. tipe monitoring ini pada dasarnya melacak setiap request yang masuk yang melewati setiap service. contoh : zipkin, jaeger.</p><p>kelebihan :</p><ul><li>bagus dalam menghubungkan request yang masuk antar service yang berbeda.</li></ul><p>kekurangan :</p><ul><li>membutuhkan koodinasi antar service.</li><li>hanya digunakan untuk memonitoring request. jadi konteksnya jika jauh jauh dari HTTP Request Style (method, header, body).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qnfhmq5Nxwz-YBNMnfLj7Q.png" /><figcaption>Jaeger</figcaption></figure><h3><strong>kesimpulan</strong></h3><p>monitoring akan membantu tim, terutama developer, untuk memiliki sistem yang reliable dan developer dapat lebih memahami bagaimana behaviour sistem di live environment dalam menangani kebutuhan dari real user. dan sebagai tambahan, monitoring akan membantu men-deliver high quality software, dan membantu mengoptimalisasi investasi di cloud environment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=78e1b76ecbac" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>