Set Format (note, tip, etc)

book/07-git-tools/sections/credentials.asc

@@ -1,49 +1,50 @@
 [[_credential_caching]]
-=== Credential Storage
+=== Kimlik Bilgisi Depolama
 
 (((credentials)))
 (((git commands, credential)))
-If you use the SSH transport for connecting to remotes, it's possible for you to have a key without a passphrase, which allows you to securely transfer data without typing in your username and password.
-However, this isn't possible with the HTTP protocols – every connection needs a username and password.
-This gets even harder for systems with two-factor authentication, where the token you use for a password is randomly generated and unpronounceable.
-
-Fortunately, Git has a credentials system that can help with this.
-Git has a few options provided in the box:
-
-* The default is not to cache at all.
-  Every connection will prompt you for your username and password.
-* The ``cache'' mode keeps credentials in memory for a certain period of time.
-  None of the passwords are ever stored on disk, and they are purged from the cache after 15 minutes.
-* The ``store'' mode saves the credentials to a plain-text file on disk, and they never expire.
-  This means that until you change your password for the Git host, you won't ever have to type in your credentials again.
-  The downside of this approach is that your passwords are stored in cleartext in a plain file in your home directory.
-* If you're using a Mac, Git comes with an ``osxkeychain'' mode, which caches credentials in the secure keychain that's attached to your system account.
-  This method stores the credentials on disk, and they never expire, but they're encrypted with the same system that stores HTTPS certificates and Safari auto-fills.
-* If you're using Windows, you can install a helper called ``Git Credential Manager for Windows.''
-  This is similar to the ``osxkeychain'' helper described above, but uses the Windows Credential Store to control sensitive information.
-  It can be found at https://github.com/Microsoft/Git-Credential-Manager-for-Windows[].
-
-You can choose one of these methods by setting a Git configuration value:
+Eğer uzak sunuculara bağlanmak için SSH taşıyıcısını kullanıyorsanız, şifresiz bir anahtarınız olabilir ve bu da kullanıcı adı ve şifrenizi yazmadan veri aktarmanıza olanak sağlar.
+Ancak, HTTP protokolleri için bu mümkün değildir; her bağlantıda bir kullanıcı adı ve şifre gereklidir.
+Bu durum, iki faktörlü kimlik doğrulama sistemlerinde daha da zorlaşır, çünkü şifreniz için kullandığınız belirteç rastgele oluşturulmuştur ve okunması zor olabilir.
+
+Neyse ki, Git'in bu konuda yardımcı olabilecek bir kimlik bilgisi sistemi vardır.
+Git'in heybesinde sakladığı bazı seçenekler şunlardır:
+
+* Varsayılan olarak hiçbir şey önbelleğe alınmaz.
+  Her bağlantı, kullanıcı adınızı ve şifrenizi girmenizi isteyecektir.
+* ``cache`` (Önbellek) modu, belirli bir süre boyunca kimlik bilgilerini bellekte tutar.
+  Hiçbir şifre hiçbir zaman diskte saklanmaz ve bunlar 15 dakika sonra önbellekten silinir.
+* ``store`` (Depolama) modu, kimlik bilgilerini düz metin dosyası halinde diskte kaydeder ve bunlar hiçbir zaman zamanaşımına uğramaz.
+  Bu, git hesabınız için şifrenizi değiştirene kadar kimlik bilgilerinizi bir daha asla girmeniz gerekmeyeceği anlamına gelir.
+  Bu yaklaşımın dezavantajı, şifrelerinizin açık metin olarak home dizininizde düz bir dosyada saklanmasıdır.
+* Bir Mac kullanıyorsanız, Git ``osxkeychain`` moduyla gelir; bu da kimlik bilgilerini sisteminize bağlı güvenli anahtar zincirinde önbelleğe alır.
+  Bu yöntem, kimlik bilgilerini diske kaydeder ve bunların süresi hiçbir zaman dolmaz, ancak bunlar HTTPS sertifikalarını ve Safari otomatik doldurmalarını saklayan aynı sistemle şifrelenir.
+* Bir Windows kullanıyorsanız, ``Git Credential Manager for Windows`` adlı bir yardımcı programı yükleyebilirsiniz.
+  Bu, yukarıda açıklanan ``osxkeychain`` yardımcı programına benzer, ancak hassas bilgileri kontrol etmek için Windows Kimlik Bilgisi Deposunu kullanır.
+  Onu şu adresten bulabilirsiniz: https://github.com/Microsoft/Git-Credential-Manager-for-Windows[].
+
+Bu yöntemlerden birini, bir Git yapılandırma değeri belirleyerek seçebilirsiniz:
 
 [source,console]
 ----
 $ git config --global credential.helper cache
 ----
 
-Some of these helpers have options.
-The ``store'' helper can take a `--file <path>` argument, which customizes where the plain-text file is saved (the default is `~/.git-credentials`).
-The ``cache'' helper accepts the `--timeout <seconds>` option, which changes the amount of time its daemon is kept running (the default is ``900'', or 15 minutes).
-Here's an example of how you'd configure the ``store'' helper with a custom file name:
+Bazı yardımcı programların çeşitli seçenekleri vardır.
+``store`` yardımcısı, `--file <dosya_yolu>` argümanını alabilir, bu da düz metin dosyasının nerede kaydedileceğini özelleştirir (varsayılan `~/.git-credentials` dizinidir).
+``cache`` yardımcısı, daemon işlemin ne kadar süreyle tutulacağını değiştiren `--timeout <saniye>` seçeneğini kabul eder (varsayılan ``900 saniye``, veya 15 dakikadır).
+İşte ``store`` yardımcısını özel bir dosya adıyla nasıl yapılandıracağınıza dair bir örnek:
 
 [source,console]
 ----
 $ git config --global credential.helper 'store --file ~/.my-credentials'
 ----
 
-Git even allows you to configure several helpers.
-When looking for credentials for a particular host, Git will query them in order, and stop after the first answer is provided.
-When saving credentials, Git will send the username and password to *all* of the helpers in the list, and they can choose what to do with them.
-Here's what a `.gitconfig` would look like if you had a credentials file on a thumb drive, but wanted to use the in-memory cache to save some typing if the drive isn't plugged in:
+Git, birkaç yardımcıyı yapılandırmanıza bile izin verir.
+Belirli bir sunucu için kimlik bilgilerini ararken, Git bunları sırayla sorgular ve bir kez cevap verildikten sonra durur.
+Kimlik bilgilerini kaydederken, Git kullanıcı adını ve şifreyi liste içindeki *tüm* yardımcılara gönderir ve onlar bunlarla ne yapacaklarına karar verebilirler.
+
+Eğer taşınabilir sürücünüzde bir kimlik bilgileri dosyanız varsa, ancak sürücü takılı değilken bazı yazma işlemlerini kaydetmek için bellek içindeki önbelleği kullanmak istiyorsanız, `.gitconfig` şu şekilde görünecektir:
 
 [source,ini]
 ----
@@ -52,14 +53,14 @@ Here's what a `.gitconfig` would look like if you had a credentials file on a th
     helper = cache --timeout 30000
 ----
 
-==== Under the Hood
+==== Şapkanın Altı
 
-How does this all work?
-Git's root command for the credential-helper system is `git credential`, which takes a command as an argument, and then more input through stdin.
+Peki tüm bunlar nasıl çalışıyor?
+Git'in kimlik bilgisi yardımcı sistemine yönelik kök komutu `git credential` 'dır. Bir komutu argüman olarak ve daha sonra daha fazla veri girişini `stdin` üzerinden alır.
 
-This might be easier to understand with an example.
-Let's say that a credential helper has been configured, and the helper has stored credentials for `mygithost`.
-Here's a session that uses the ``fill'' command, which is invoked when Git is trying to find credentials for a host:
+Bir örnek ile bunu anlamak daha kolay olacaktır.
+Diyelim ki yapılandırılmış bir kimlik bilgisi yardımcısı, `mygithost` için kimlik bilgilerini saklamış olsun.
+İşte, Git'in bir sunucu için kimlik bilgilerini bulmaya çalışırken çağrılan ``fill`` komutunu kullanan bir oturum:
 
 [source,console]
 ----
@@ -83,39 +84,39 @@ username=bob
 password=s3cre7
 ----
 
-<1> This is the command line that initiates the interaction.
-<2> Git-credential is then waiting for input on stdin.
-    We provide it with the things we know: the protocol and hostname.
-<3> A blank line indicates that the input is complete, and the credential system should answer with what it knows.
-<4> Git-credential then takes over, and writes to stdout with the bits of information it found.
-<5> If credentials are not found, Git asks the user for the username and password, and provides them back to the invoking stdout (here they're attached to the same console).
+<1> Bu etkileşimi başlatan komut satırıdır.
+<2> Ardından, Git-credential stdin üzerinden giriş bekler.
+    Bildiklerimizi giriyoruz: protokol ve sunucu adı.
+<3> Boş bir satır, girişin tamamlandığını ve kimlik bilgisi sisteminin ne bildiğini yanıtlaması gerektiğini gösterir.
+<4> Daha sonra, Git-credential işi devralır ve bulduğu bilgileri stdout ile yazar.
+<5> Kimlik bilgileri bulunamazsa; Git kullanıcıya kullanıcı adını ve şifreyi sorup, bunları başlatan stdout'a sağlar (burada aynı konsola bağlanmışlardır).
 
-The credential system is actually invoking a program that's separate from Git itself; which one and how depends on the `credential.helper` configuration value.
-There are several forms it can take:
+Kimlik bilgisi sistemi aslında Git'ten ayrı bir programı çağırır. Hangi programın çağrıldığı ve nasıl olduğu, `credential.helper` yapılandırma değerine bağlıdır.
+Bu, birkaç farklı biçimde olabilir:
 
 [options="header"]
 |======
-| Configuration Value | Behavior
-| `foo` | Runs `git-credential-foo`
-| `foo -a --opt=bcd` | Runs `git-credential-foo -a --opt=bcd`
-| `/absolute/path/foo -xyz` | Runs `/absolute/path/foo -xyz`
-| `!f() { echo "password=s3cre7"; }; f` | Code after `!` evaluated in shell
+| Yapılandırma Değeri | Davranış
+| `foo` | `git-credential-foo` çalışır
+| `foo -a --opt=bcd` | `git-credential-foo -a --opt=bcd` çalışır
+| `/absolute/path/foo -xyz` | `/absolute/path/foo -xyz` çalışır
+| `!f() { echo "password=s3cre7"; }; f` | `!` sonrasındaki kod kabukta (shell) değerlendirilir
 |======
 
-So the helpers described above are actually named `git-credential-cache`, `git-credential-store`, and so on, and we can configure them to take command-line arguments.
-The general form for this is ``git-credential-foo [args] <action>.''
-The stdin/stdout protocol is the same as git-credential, but they use a slightly different set of actions:
+Yukarıda tanımlanan yardımcılar aslında `git-credential-cache`, `git-credential-store`, vb. şeklinde adlandırılmıştır ve onları komut satırı argümanları alacak şekilde yapılandırabiliriz.
+Bunun genel formu ``git-credential-foo [args] <eylem>.`` şeklindedir.
+Stdin/stdout protokolü git-credential ile aynıdır, ancak biraz farklı bir eylem kümesi kullanırlar:
 
-* `get` is a request for a username/password pair.
-* `store` is a request to save a set of credentials in this helper's memory.
-* `erase` purge the credentials for the given properties from this helper's memory.
+- `get`: Kullanıcı adı/şifre isteği.
+- `store`: Bu yardımcının belleğine, bir kimlik bilgisi kümesini kaydetme isteği.
+- `erase`: Belirtilen özelliklere sahip kimlik bilgilerini, bu yardımcının belleğinden silme işlemi.
 
-For the `store` and `erase` actions, no response is required (Git ignores it anyway).
-For the `get` action, however, Git is very interested in what the helper has to say.
-If the helper doesn't know anything useful, it can simply exit with no output, but if it does know, it should augment the provided information with the information it has stored.
-The output is treated like a series of assignment statements; anything provided will replace what Git already knows.
+`store` ve `erase` eylemleri için yanıt gerekli değildir (zaten Git tarafından görmezden gelinir).
+Ancak Git, `get` eylemi için yardımcının ne söylediğini çok önemser.
+Yardımcı işe yarar bir şey bilmiyorsa, herhangi bir çıktı olmadan doğrudan çıkış yapabilir; ancak biliyorsa, sağlanan bilgiyi depoladığı bilgilerle genişletmesi gerekir.
+Çıktı, bir dizi atama ifadesi gibi işlenir; sağlanan her bir şey, Git'in zaten bildiği şeyi değiştirecektir.
 
-Here's the same example from above, but skipping git-credential and going straight for git-credential-store:
+İşte yukarıdaki örneğin, git-credential'ı atlayarak doğrudan git-credential-store'a geçen bir şekli:
 
 [source,console]
 ----
@@ -132,49 +133,54 @@ username=bob <3>
 password=s3cre7
 ----
 
-<1> Here we tell `git-credential-store` to save some credentials: the username ``bob'' and the password ``s3cre7'' are to be used when `https://mygithost` is accessed.
-<2> Now we'll retrieve those credentials.
-    We provide the parts of the connection we already know (`https://mygithost`), and an empty line.
-<3> `git-credential-store` replies with the username and password we stored above.
+<1> Burada `git-credential-store` 'a bazı kimlik bilgilerini kaydetmesini söylüyoruz: `https://mygithost` erişildiğinde kullanıcı adı olarak ``bob`` ve şifre olarak ``s3cre7`` kullanılacaktır.
+<2> Şimdi bu kimlik bilgilerini alacağız.
+    Zaten bildiğimiz bağlantının parçalarını sağlıyoruz (`https://mygithost`) ve bir boş satır ekliyoruz.
+<3> `git-credential-store`, yukarıda sakladığımız kullanıcı adı ve şifre ile yanıt verir.
 
-Here's what the `~/git.store` file looks like:
+İşte `~/git.store` dosyasının içeriği:
 
 [source,ini]
 ----
 https://bob:s3cre7@mygithost
 ----
 
-It's just a series of lines, each of which contains a credential-decorated URL.
-The `osxkeychain` and `wincred` helpers use the native format of their backing stores, while `cache` uses its own in-memory format (which no other process can read).
+Bu sadece kimlik bilgisiyle bezenmiş URL'lerini içeren bir dizi satırdır.
+`osxkeychain` ve `wincred` yardımcıları, destek depolarının doğal formatını kullanırken, `cache` kendi bellek içi formatını kullanır (ki bu diğer hiçbir süreç tarafından okunamaz).
 
 ==== A Custom Credential Cache
 
-Given that `git-credential-store` and friends are separate programs from Git, it's not much of a leap to realize that _any_ program can be a Git credential helper.
-The helpers provided by Git cover many common use cases, but not all.
-For example, let's say your team has some credentials that are shared with the entire team, perhaps for deployment.
-These are stored in a shared directory, but you don't want to copy them to your own credential store, because they change often.
-None of the existing helpers cover this case; let's see what it would take to write our own.
-There are several key features this program needs to have:
+`git-credential-store` ve benzerleri, Git'ten bağımsız ayrı programlardır, bu nedenle _herhangi bir_ programın bir Git kimlik bilgisi yardımcısı olabileceğini anlamak pek de zor değildir. 
+Git'in sağladığı yardımcılar birçok yaygın kullanım durumunu kapsar, ancak hepsini değil. 
+Örneğin, diyelim ki ekibinizin, belki de dağıtım için, tüm ekiple paylaşılan bazı kimlik bilgileri var. 
+Bu kimlik bilgileri, paylaşılan bir dizinde saklanır, ancak sık sık değiştiği için bunları kendi kimlik bilgisi deposuna kopyalamak istemezsiniz. 
+Mevcut yardımcıların hiçbiri bu durumu kapsamaz. Şimdi kendimiz bir tane yazmak istersek ne gerektiğini görelim. 
+Bu programın sahip olması gereken birkaç temel özellik bulunmaktadır:
 
-. The only action we need to pay attention to is `get`; `store` and `erase` are write operations, so we'll just exit cleanly when they're received.
-. The file format of the shared-credential file is the same as that used by `git-credential-store`.
-. The location of that file is fairly standard, but we should allow the user to pass a custom path just in case.
+. Dikkat etmemiz gereken tek işlem `get` işlemidir: `store` ve `erase` yazma işlemleri olduğu için, bunları aldığımızda sadece temiz bir şekilde çıkış yaparız.
+. Paylaşılan kimlik bilgisi dosyasının dosya biçimi, `git-credential-store` tarafından kullanılan dosya biçimi ile aynıdır.
+. Dosyanın yeri oldukça standarttır, ancak her ihtimale karşı kullanıcının özel bir dizin geçmesine izin vermeliyiz.
 
-Once again, we'll write this extension in Ruby, but any language will work so long as Git can execute the finished product.
-Here's the full source code of our new credential helper:
+Bu uzantıyı yine Ruby'de yazacağız, ancak Git, bitmiş kodu çalıştırabileceği sürece herhangi bir dil de işe yarayacaktır. 
+İşte yeni kimlik bilgisi yardımcımızın tam kaynak kodu:
 
 [source,ruby]
 --------
 include::../git-credential-read-only[]
 --------
 
-<1> Here we parse the command-line options, allowing the user to specify the input file.
-    The default is `~/.git-credentials`.
-<2> This program only responds if the action is `get` and the backing-store file exists.
-<3> This loop reads from stdin until the first blank line is reached.
-    The inputs are stored in the `known` hash for later reference.
-<4> This loop reads the contents of the storage file, looking for matches.
-    If the protocol and host from `known` match this line, the program prints the results to stdout and exits.
+<1> Burada komut satırı seçeneklerini ayrıştırıyoruz ve kullanıcının giriş dosyasını belirtmesine izin veriyoruz. 
+    Varsayılan `~/.git-credentials`'dır.
+<2> Bu program, sadece eylem `get` ise ve destek dosyası mevcutsa yanıt verir.
+<3> Bu döngü, ilk boş satıra ulaşılıncaya kadar stdin'den okur. 
+    Girişler daha sonra başvurmak üzere `known` hash'inde saklanır.
+<4> Bu döngü, depolama dosyasının içeriğini okur ve eşleşmeleri arar. 
+    `known`'dan gelen protokol ve sunucu bu satırla eşleşiyorsa, program sonuçları stdout'a yazdırır ve çıkar.
+
+Yardımcımızı `git-credential-read-only` olarak kaydedeceğiz, bunu `PATH` içinde bir yere koyacağız ve çalıştırılabilir olarak işaretleyeceğiz. 
+İşte etkileşimli bir oturumun nasıl göründüğü:
+
+
 
 We'll save our helper as `git-credential-read-only`, put it somewhere in our `PATH` and mark it executable.
 Here's what an interactive session looks like:
@@ -191,11 +197,11 @@ username=bob
 password=s3cre7
 ----
 
-Since its name starts with ``git-'', we can use the simple syntax for the configuration value:
+Adı "git-" ile başladığından, yapılandırma değeri için basit sözdizimini kullanabiliriz:
 
 [source,console]
 ----
 $ git config --global credential.helper 'read-only --file /mnt/shared/creds'
 ----
 
-As you can see, extending this system is pretty straightforward, and can solve some common problems for you and your team.
+Gördüğünüz gibi, bu sistemi genişletmek oldukça basit ve sizin ve ekibinizin bazı yaygın sorunlarını çözebilir.