Forem: Rıdvan Tülemen

Golang'de LDAP Authentication, Bind ve Search

Rıdvan Tülemen — Wed, 30 Jun 2021 19:32:12 +0000

Windows Active Directory veya Samba hakkında bilginiz varsa, LDAP hakkında halihazırda bilginiz olabilir. Ama yoksa, Wikipedia'daki açıklama şu şekildedir.

Lightweight Directory Access Protocol veya kısaca LDAP (Türkçe: Basit İndeks Erişim Protokolü) TCP/IP üzerinde çalışan indeks servislerini sorgulama ve değiştirme amacıyla kullanılan uygulama katmanı protokolü.

Projeyi Oluşturmak

İlk olarak, kütüphaneyi indirmemiz gerekiyor:

go get github.com/go-ldap/ldap

Değişkenler

Artık kütüphaneyi kullanmaya başlayabiliriz. İlk olarak, daha sonra kullanacağımız değişkenleri oluşturuyoruz(Eğer anonymous bind kullanacaksanız sadece Filter değişkeni yeterlidir):

const (
    BindUsername = "user@example.com"
    BindPassword = "password"
    FQDN         = "DC.example.com"
    BaseDN       = "cn=Configuration,dc=example,dc=com"
    Filter       = "(objectClass=*)"
)

Connect

LDAP'a bağlanmak için, ldap.DialURL() fonksiyonunu kullanacağız. Aşağıdaki fonksiyon sadece bağlantı için kullanılacak bir fonksiyondur:

// Ldap Connection without TLS
func Connect() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldap://%s:389", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

TLS Connect

Eğer TLS Connection kullanmak istiyorsanız, aşağıdaki fonksiyonu kullanabilirsiniz:

// Ldap Connection with TLS
func ConnectTLS() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldaps://%s:636", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

Anonymous Bind ve Search

Eğer anonymous bind kullanmak istiyorsanız, bu fonksiyonu kullanabilirsiniz:

// Anonymous Bind and Search
func AnonymousBindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.UnauthenticatedBind("")

    anonReq := ldap.NewSearchRequest(
        "",
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(anonReq)
    if err != nil {
        return nil, fmt.Errorf("Anonymous Bind Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        result.Entries[0].Print()
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch anonymous bind search entries")
    }
}

Bind ve Search

Onun yerine, normal bind kullanmak isterseniz:

// Normal Bind and Search
func BindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.Bind(BindUsername, BindPassword)

    searchReq := ldap.NewSearchRequest(
        BaseDN,
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(searchReq)
    if err != nil {
        return nil, fmt.Errorf("Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch search entries")
    }
}

Main Fonksiyon

Son olarak, bu fonksiyonları kullanabileceğimiz bir main fonksiyona ihtiyacımız var.

TLS Connection ile Bind ve Search

func main() {
    // TLS Connection
    l, err := ConnectTLS()
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    // Normal Bind and Search
    result, err = BindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()
}

Non-TLS Connection ile Anonymous Bind ve Search

func main() {
    // Non-TLS Connection
    l, err := Connect()
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    // Anonymous Bind and Search
    result, err := AnonymousBindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()
}

Son Olarak

Bu fonksiyonlar ile LDAP ile Authentication, bind ve search'ün anlaşılabildiğini düşünüyorum. Sonunda kod aşağıdaki gibi bir hale geliyor:

package main

import (
    "fmt"
    "log"

    "github.com/go-ldap/ldap/v3"
)

const (
    BindUsername = "user@example.com"
    BindPassword = "password"
    FQDN         = "DC.example.com"
    BaseDN       = "cn=Configuration,dc=example,dc=com"
    Filter       = "(objectClass=*)"
)

func main() {
    // TLS Connection
    l, err := ConnectTLS()
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    // Non-TLS Connection
    //l, err := Connect()
    //if err != nil {
    //  log.Fatal(err)
    //}
    //defer l.Close()

    // Anonymous Bind and Search
    result, err := AnonymousBindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()

    // Normal Bind and Search
    result, err = BindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()
}

// Ldap Connection with TLS
func ConnectTLS() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldaps://%s:636", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

// Ldap Connection without TLS
func Connect() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldap://%s:389", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

// Anonymous Bind and Search
func AnonymousBindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.UnauthenticatedBind("")

    anonReq := ldap.NewSearchRequest(
        "",
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(anonReq)
    if err != nil {
        return nil, fmt.Errorf("Anonymous Bind Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        result.Entries[0].Print()
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch anonymous bind search entries")
    }
}

// Normal Bind and Search
func BindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.Bind(BindUsername, BindPassword)

    searchReq := ldap.NewSearchRequest(
        BaseDN,
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(searchReq)
    if err != nil {
        return nil, fmt.Errorf("Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch search entries")
    }
}

Ayrıca, oluşturduğum gist'e de göz atabilirsiniz.

Okduğunuz için teşekkürler. Umarım yardımcı olabilmişimdir.

LDAP Authentication in Golang with Bind and Search

Rıdvan Tülemen — Wed, 30 Jun 2021 19:31:52 +0000

If you are familiar with the Windows Active Directory or Samba, you may have already heard about LDAP. But if you didn't, here is the description in Wikipedia.

Lightweight Directory Access Protocol (LDAP) is an open, vendor-neutral, industry standard application protocol for accessing and maintaining distributed directory information services over an Internet Protocol (IP) network.

Creating our project

First of all, we need to download the library:

go get github.com/go-ldap/ldap

Variables

Now, we can start using the library. Firstly, we are creating the variables to use them later(If you are going to use anonymous bind, you only need Filter):

const (
    BindUsername = "user@example.com"
    BindPassword = "password"
    FQDN         = "DC.example.com"
    BaseDN       = "cn=Configuration,dc=example,dc=com"
    Filter       = "(objectClass=*)"
)

Connect

To connect to LDAP, we can use ldap.DialURL() func. Followed function is solely created to connect to an LDAP server:

// Ldap Connection without TLS
func Connect() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldap://%s:389", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

TLS Connect

If you need TLS Connection, you can use the function below:

// Ldap Connection with TLS
func ConnectTLS() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldaps://%s:636", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

Anonymous Bind and Search

If you want anonymous bind in your project, you can use this function:

// Anonymous Bind and Search
func AnonymousBindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.UnauthenticatedBind("")

    anonReq := ldap.NewSearchRequest(
        "",
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(anonReq)
    if err != nil {
        return nil, fmt.Errorf("Anonymous Bind Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        result.Entries[0].Print()
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch anonymous bind search entries")
    }
}

Bind and Search

If you prefer normal binding instead:

// Normal Bind and Search
func BindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.Bind(BindUsername, BindPassword)

    searchReq := ldap.NewSearchRequest(
        BaseDN,
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(searchReq)
    if err != nil {
        return nil, fmt.Errorf("Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch search entries")
    }
}

Main Func

Last of all, we need to create a main function to use these functions:

Bind and Search with TLS Connection

func main() {
    // TLS Connection
    l, err := ConnectTLS()
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    // Normal Bind and Search
    result, err = BindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()
}

Anonymous Bind and Search with Non-TLS Connection

func main() {
    // Non-TLS Connection
    l, err := Connect()
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    // Anonymous Bind and Search
    result, err := AnonymousBindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()
}

Conclusion

After these functions, I believe you can start using LDAP authentication, bind and search. At the end, the code should look like this:

package main

import (
    "fmt"
    "log"

    "github.com/go-ldap/ldap/v3"
)

const (
    BindUsername = "user@example.com"
    BindPassword = "password"
    FQDN         = "DC.example.com"
    BaseDN       = "cn=Configuration,dc=example,dc=com"
    Filter       = "(objectClass=*)"
)

func main() {
    // TLS Connection
    l, err := ConnectTLS()
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    // Non-TLS Connection
    //l, err := Connect()
    //if err != nil {
    //  log.Fatal(err)
    //}
    //defer l.Close()

    // Anonymous Bind and Search
    result, err := AnonymousBindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()

    // Normal Bind and Search
    result, err = BindAndSearch(l)
    if err != nil {
        log.Fatal(err)
    }
    result.Entries[0].Print()
}

// Ldap Connection with TLS
func ConnectTLS() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldaps://%s:636", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

// Ldap Connection without TLS
func Connect() (*ldap.Conn, error) {
    // You can also use IP instead of FQDN
    l, err := ldap.DialURL(fmt.Sprintf("ldap://%s:389", FQDN))
    if err != nil {
        return nil, err
    }

    return l, nil
}

// Anonymous Bind and Search
func AnonymousBindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.UnauthenticatedBind("")

    anonReq := ldap.NewSearchRequest(
        "",
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(anonReq)
    if err != nil {
        return nil, fmt.Errorf("Anonymous Bind Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        result.Entries[0].Print()
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch anonymous bind search entries")
    }
}

// Normal Bind and Search
func BindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
    l.Bind(BindUsername, BindPassword)

    searchReq := ldap.NewSearchRequest(
        BaseDN,
        ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
        ldap.NeverDerefAliases,
        0,
        0,
        false,
        Filter,
        []string{},
        nil,
    )
    result, err := l.Search(searchReq)
    if err != nil {
        return nil, fmt.Errorf("Search Error: %s", err)
    }

    if len(result.Entries) > 0 {
        return result, nil
    } else {
        return nil, fmt.Errorf("Couldn't fetch search entries")
    }
}

You can also check out the gist I created.

Thank you for reading. I hope you found this article helpful.

Git ve Github Nedir, Nasıl Kullanılır - Örnekler

Rıdvan Tülemen — Sun, 27 Jun 2021 12:34:50 +0000

Fork Örnek

Github üzerinden Fork butonuna basarak repoyu forkluyoruz. Daha sonrasında bu reponun kendi hesabımızda bir forkunun oluştuğunu görebiliriz.

https://github.com/<YourName/<Repository>

Uygulama

Öncelikle forkladığımız repoyu cloneluyoruz

git clone https://github.com/<YourName/<Repository>

Daha sonrasında istediğimiz değişiklikleri yerel repomuzda yaparak, aşağıdaki adımlar ile kendi uzak forkumuza pushluyoruz

git checkout -b <BranchName>
git add .
git commit -m "commit mesajı"
git push -u origin <BranchName>

Bu adımdan sonra Github üzerinden Compare & pull request butonuna basarak Pull Request oluşturuyoruz.

Aşağıdaki ekran görüntüsünde de gözüktüğü gibi, asıl repodaki mergelemek istediğimiz branchi seçiyoruz, istersek Leave a comment kısmına yaptığımız değişiklikler hakkında detaylı bilgi veriyoruz ve Create pull request butonuna basıyoruz

İşlemleri doğru bir şekilde yaptıysanız, aşağıdaki gibi bir ekran göreceksiniz

Stash Örnek

Eğer yerel reponuzda bir değişiklik yaptıktan sonra ve commitlemeden önce, asıl repoda, sizin son pullunuzdan sonra değişiklik yapılmış ise, değişiklikleri kaydetmeden asıl repoyu pulllamak isterseniz aşağıdaki gibi bir hata alırsınız

Please commit your changes or stash them before you merge.

Bunun çözümü olarak da aşağıdaki yol izlenir

git stash
git pull upstream <BranchName>
git stash pop

Bu komutlar sırasıyla, önce yaptığınız değişiklikleri stashe atar. Daha sonrasında asıl repodaki değişiklikleri yerel reponuza çeker. Son olarak da, öncesinde stashlediğimiz değişiklikleri poplayarak, değişiklikleri kaybetmemizi engellemiş olur.

Git ve Github Nedir, Nasıl Kullanılır

Rıdvan Tülemen — Sun, 27 Jun 2021 12:34:25 +0000

Git nedir

Git, kısaca versiyon kontrol sistemidir. Bu söylemi açarsak; yazdığınız programı, kodu veya herhangi bir dosyalar topluluğunu, versiyonlara ayırarak ve iterasyonlar halinde geliştirmek istiyorsanız kullanacağınız sistem diyebiliriz.

Git yerel olarak, sizin bilgisayarınızda bulunan bir uygulamadır. Github ise Git ile yazılan projeler için bir depolama servisidir

Kurulum

Ben kurulumu Debian tabanlı sistemler için anlatacağım, ama küçük bir araştırma ile kolayca kendi işletim sisteminizdeki yükleme şeklini bulabilirsiniz

sudo apt install git

Kullanım

Eğer bir dizinde, git initialize ederek, local repository oluşturabiliriz. Bunu yaparken .git dizini de otomatik olarak oluşacaktır.

git init

Veya, halihazırdaki bir repository'i clone'layıp bilgisayarımıza indirmek istiyorsak:

git clone <link>

Örnek olarak

git clone https://github.com/limanmys/core

Not

git clone ve Github üzerindeki Download butonu aynı şey değildir. Github üzerinden indirirseniz .git klasörü olmadığı için, geliştirmeye devam ederek commit veya push atamayız.

Bu noktada git credential'larımızı girmemiz gerekiyor

git config --global user.email "you@example.com"
git config --global user.name "YourName"

Add

Daha sonrasında, yerel çalışma ortamımızda yaptığımız değişiklikleri staging area dediğimiz yerel alana almak için:

git add .

Veya tek bir dosya, dizin vs. almak istiyorsak

git add dosya
git add dizin/

şeklinde kullanabiliriz. Bu işlem sonrasında bu değişiklikler bizim local repository'mize değil, sadece staging area içerisine kaydolmuş olur.

Not

git add öncesinde ve sonrasında aşağıdaki komut ile, sırasıyla, öncesinde eklenmemiş dosyaları ve sonrasında ise eklemiş dosyaların durumunu görebilirsiniz

git status

Commit

Bunları local repository'e eklemek için:

git commit -m "commit mesajı"

Bunu yaptığımızda, kodumuz hala daha local repository'de bulunur.

Daha kolay anlayabilmeniz için bir görsel

Görsel git-scm.com'dan alınmıştır

Remote add

Bunu uzaktaki sunucumuza aktarmak için, önce sunucunun adresini aşağıdaki komut ile belirtmemiz gerekiyor(eğer clone'ladıktan sonra geliştirme yapıyorsanız buna gerek yoktur)

git remote add origin <link>

Burada origin ismi bizim kendi belirlediğimiz bir isimdir. İstediğiniz ismi koyabilirsiniz. Ama origin ismi genel kullanımdır ve tercih edilir.

Örnek olarak

git remote add origin https://github.com/limanmys/core

Push

Pushlamadan önce, eğer ana repo branchimiz main ise aşağıdaki komut ile yereldeki git üzerinden branch'i main yapabiliriz

git branch -M main

Daha sonrasında uzak depomuza bu değişiklikleri göndermek için

git push -u origin main

kullanılır. Buradaki main branch ismimizdir. Kullanımınıza göre değişiklik gösterir.

Not

Eğer -u parametresini kullanırsanız, uzaktaki branch ile yerel branch'inizi birbirine eşitleyerek
git pull origin main yerine git pull kullanarak işlem yapabilmenizi sağlar.

Bu komutu yazdığınızda, eğer ilk git kullanımınız ise, size Username ve Password soracaktır. Bu bilgileri girdiğinizde kodunuz uzaktaki sunucuya gitmiş olacaktır.

Not

Eğer Github hesabınızda Two Factor Authentication açıksa, şifre yerine Github üzerinden alacağınız bir tokeni, veya yerelde oluşturacağınız bir SSH anahtarını Github hesabınıza eklemeniz gerekir. Ben SSH anahtarı oluşturmayı öneriyorum.

Remote mantığını anlayabilmek için bir görsel daha

Görsel bu linkten alınmıştır

Pull

Bu noktadan sonra bizim dışımızda birinin yaptığı değişiklikleri yerel repomuza çekmek için

git pull origin main

veya -u parametresini kullandıysanız

git pull

komutunu kullanabilirsiniz. Dosyanızın yerel reponuza geldiğini göreceksiniz.

Fork

Github üzerinden forkladığımız repo'yu clone'layarak yerel repo oluşturabilirsiniz. Bu repo'nun origin'i kendi fork'unuzun ismi olacağı için, upstream, yani fork'ladığınız repo'nun remote olarak eklenmesi gerekir.

git remote add upstream https://github.com/<OriginalUser>/<OriginalRepo>

Not

upstream genel olarak tercih edilen isimdir.

Eğer fork'ladığınız repoda bir değişiklik varsa ve bunu kendi repo'nuz ile eşitlemek isterseniz

git fetch upstream
git checkout main
git merge upstream/main

Branch

Eğer farklı bir branch üzerinde çalışmak isterseniz

git checkout -b <branch_adı>

ile yeni branch'i oluşturup, o branch üzerinde çalışmaya başlayabilirsiniz. -b parametresi olmadan da halihazırda bulunan bir branch'e geçilebilir

git checkout main

Eğer yereldeki bir branchi silmek isterseniz

git branch -d <BranchName>

Stash

Eğer halihazırda bazı değişiklikler yaptıktan sonra, henüz push'lamadan, reponuzun herhangi bir branch'indeki değişiklikleri yerel reponuza uygulamak isterseniz

git stash
git pull
git stash pop

Commit Amend

Eğer son aldığınız commit mesajını değiştirmek isterseniz

git add .
git commit -amend -m "yeni commit mesajı"

kullanabilirsiniz.

Reset

Push'lamadığınız değişiklikleri geri almak için;

HEAD'e geri dönmek için(son remote commit veya son push)

git reset --hard HEAD

Not

Bu kısımlardaki komutlarda, --hard parametresi, değişikliklerinizin kaybolmasına yol açar. Eğer değişikliklerinizi kaybetmeden dönmek istiyorsanız, --soft parametresini kullanabilirsiniz

git reset --soft HEAD

git reset --hard HEAD~1     (bir önceki commit'e gitmek)

git reset --hard HEAD~2     (iki önceki commit'e gitmek)

Hard Reset Geri Alma

Hard reset geri almak için

git reset --hard HEAD@{1}

Revert

Eğer hard reset ile kaybedeceğiniz commit'leri kaybetmek istemiyor ve onların da commit geçmişinde bulunmasını istiyorsanız

git revert HEAD

Bu komut için hash kullanmanız da gerekebilir. Bunun için

git log

ile dönmek istediğimiz commit'in hash'ini bularak

git revert [hash]

Diff

Git'teki değişiklikleri görmek için

git diff

veya git add ile stage'lemişseniz

git diff --staged

Set Up Ruby on Rails Server on Ubuntu Server 20.04

Rıdvan Tülemen — Thu, 06 Aug 2020 14:36:50 +0000

Installation and running processes for the Rails Server we have created for the Yusufreis are as described below.

Downloading Files

Download the Server's files at first.

git clone https://github.com/starbuckr/railsserver

Then, go to the directory where our project is located and install necessary packages.

cd railsserver
sudo apt install ruby ruby-dev ruby-bundler nodejs npm libsqlite3-dev zlib1-dev
sudo npm install yarn -g
yarn install --check-files

Configuring Rails Server's Settings

If the Ruby version you are currently using is not 2.5.5, you need to change the ruby '2.5.5' line in the Gemfile. For example, if your Ruby version is 2.7.0 we need to edit it as this.

ruby '2.7.0'

After installing packages, configure Gem and database settings.

sudo bundle install
rails db:migrate

Running The Server

In order to run the server, use rails server or rails s command.

rails s

If you want to connect the server from other local machines, you need to change running ip address.

rails s -b 0.0.0.0

You can then access this server from any device connected to that network. For example, if the ip address of our Ubuntu Server machine is 192.168.1.56, you can access the server by entering the address 192.168.1.56:3000 in your browser.

Ubuntu 20.04 üzerinde Ruby on Rails Kurulumu

Rıdvan Tülemen — Thu, 06 Aug 2020 14:03:27 +0000

Yusufreis programı için oluşturduğumuz Rails Sunucu için kurulum ve çalıştırma adımları aşağıda anlatıldığı gibidir.

Dosyaların İndirilmesi

Öncelikle Sunucunun dosyaları indirilir.

git clone https://github.com/starbuckr/railsserver

Daha sonra projemizin bulunduğu dizine girip, gerekli paketler yüklenir.

cd railsserver
sudo apt install ruby ruby-dev ruby-bundler nodejs npm libsqlite3-dev zlib1-dev
sudo npm install yarn -g
yarn install --check-files

Rails Sunucunun Ayarlarının Yapılması

Eğer hali hazırda kullandığınız Ruby versiyonu 2.5.5 değilse, Gemfile içerisindeki ruby '2.5.5' satırını değiştirmeniz gerekir. Örnek olarak eğer Ruby versiyonunuz 2.7.0 ise bu şekilde düzenlememiz gerekir.

ruby '2.7.0'

Paketleri kurduktan sonra Rails sunucunun Gem ve veritabanı ayarları yapılır.

sudo bundle install
rails db:migrate

Sunucuyu Çalıştırma

Sunucuyu çalıştırmak için, dosyaların bulunduğu klasörde rails server veya rails s komutu çalıştırılır.

rails s

Eğer sunucunuza, aynı ağdaki başka bir makineden bağlanmak isterseniz, çalıştırırken kullandığı ip adresini değiştirmeniz gerekir.

rails s -b 0.0.0.0

Daha sonrasında o ağa bağlı herhangi bir cihazdan bu sunucuya erişebilirsiniz. Örnek olarak, Ubuntu Server makinemizin ip adresi 192.168.1.56 ise, tarayıcınızdan 192.168.1.56:3000 adresine girerek sunucuya erişebilirsiniz.