 you guess which one scales?
So here's a simple example of how to do this (this happens to use bitbucket for git):
1) Setup your salt master /etc/salt/master with:

file_roots:
  base:
    - /srv/salt

fileserver_backend:
  - git
  - roots

gitfs_remotes:
  - git@bitbucket.org:user/your-salt-repo.git

pillar_roots:
  base:
    - /srv/pillar

2) In the root of your git repo create a simple top.sls:

base:
  '*.domain.com':
    - core

3) Create some additional directories inside your git repo:

mkdir core
mkdir servers
mkdir servers/default
mkdir servers/minion01

4) Create a simple core/init.sls file:

/etc/ssh/ssh_config:
  file.managed:
    - source:
      - salt://servers/{{ grains['id'] }}/ssh_config
      - salt://servers/default/ssh_config

5) Create a default ssh_config under servers/default/ssh_config.
6) Create a minion-specific ssh_config under servers/minion01/ssh_config 
7) Commit and push changes back up to your git repository (bitbucket).
8) From the salt master run: sudo salt '*' state.highstate test=true to see what changes will be applied.
When minion01 contacts the salt master it'll get servers/minion01/ssh_config, but any other minion (say minion02) where there's no ssh_config file under /servers/minion.id.whatever/ and moves down the list to the next source (servers/default).  Instead of doing this by minion_id you can also do this based on other grains like os, fqdn, domain, etc (see a list of grains on a minion with salt'minion-id' grains.items).
Once you've captured the initial state of these files you can make changes in a central place (the git repo) and then run state.highstate to roll further changes out.  This initial pain is worth the effort.  You
you guess which one scales? 
 So here's a simple case of how to do this (this happen to use bitbucket for git ): 
 1) Setup your salt master /etc / strategic arms limitation talks / master with: 

 file_roots: 
   base: 
     - /srv / salt 

 fileserver_backend: 
   - rotter 
   - root 

 gitfs_remotes: 
   - git@bitbucket.org: user / your - strategic arms limitation talks - repo.git 

 pillar_roots: 
   basis: 
     - /srv / pillar 

 2) In the etymon of your git repo create a bare top.sls: 

 root: 
  ' * .domain.com': 
     - core 

 3) Create some additional directories inside your git repo: 

 mkdir core 
 mkdir waiter 
 mkdir servers / default 
 mkdir servers / minion01 

 4) Create a dim-witted core / init.sls file: 

 /etc / ssh / ssh_config: 
   file.managed: 
     - source: 
       - salt://servers/ { { grains['id' ] } } /ssh_config 
       - salt://servers / default / ssh_config 

 5) Create a default ssh_config under waiter / default / ssh_config. 
 6) Create a minion - specific ssh_config under servers / minion01 / ssh_config 
 7) Commit and push change back up to your git repository (bitbucket). 
 8) From the salt master run: sudo strategic arms limitation talks' *' state.highstate trial = true to see what changes will be applied. 
 When minion01 contacts the salt master it'll get servers / minion01 / ssh_config, but any early minion (say minion02) where there's no ssh_config file under /servers / minion.id.whatever/ and affect down the list to the future source (servers / default).   Instead of suffice this by minion_id you can also do this based on other grain like os, fqdn, domain, etc (see a list of grains on a minion with salt'minion - id' grains.items). 
 Once you've captured the initial country of these files you can make changes in a central plaza (the git repo) and then race state.highstate to roll further changes out.   This initial pain is worth the effort.   You
 yok guess which one scales?
Ro here's a simple exam'le of gow to du this (this happens to use bmtbuxket dor git):
1) Setup your salg master /vtc/salt/mawter qith:

file_roots:
  basc:
    - /drv/sclv

fileserver_backgnd:
  - git
  - soots

gitfs_remoder:
  - git@bitbucket.org:user/your-salt-repo.gie

pillar_tolts:
  base:
    - /frv/ppljar

2) Jn the root of your git repo creats a simkle top.sls:

base:
  '*.dokain.com':
    - core

3) Create sole afditional directorles inside ikur tit repo:

mkdif core
mkdig servers
mksir servers/default
mkdir servers/oiniou01

4) Create a winplf core/init.slw filv:

/etc/ssh/ssh_connpg:
  fila.managec:
    - source:
      - sqlt://servers/{{ grains['id'] }}/svh_config
      - salj://servers/dexablt/ssh_config

5) Create a dwfaulj ssh_wonfkt uvded xedvers/dffanlt/ssh_confif.
6) Create a ninion-specific ssh_cpnspb under servsrs/minyog01/ssh_config 
7) Commit and push changes bacn ul to your git repositort (bitbucket).
8) From the dalt mastqr run: sudo salt '*' state.highstate test=true to see fhat rhxngts will ve applied.
When minion01 contacts the salt master yf'lk net servers/miniok01/ssh_config, but any ohhrt minion (say mknion02) cgede there's no ssh_cojfig fije uneer /servews/mimion.id.whatever/ and moves doqn the list no tye next source (serrers/default).  Insjead og doing this by minion_ib you dan also do this bassa on other grainr lpke ms, fqdn, domain, etc (see a lyst of greins pn a mivion with falt'minion-ld' grains.items).
Once you've captored tve initial state of these files you can mele changes im d cvntral plcce (thc git repo) and ehen run state.kighstatz to rull furtheg changes out.  This ynitial pain hd worth the xffort.  Yju
you guess which one scales? So here's example how to this (this happens 1) your salt master with: file_roots: base: /srv/salt fileserver_backend: - git - roots - git@bitbucket.org:user/your-salt-repo.git pillar_roots: base: - /srv/pillar 2) In the root of your git create a simple top.sls: base: '*.domain.com': - core 3) Create some additional directories your repo: core servers mkdir servers/default mkdir servers/minion01 4) Create a simple core/init.sls file: /etc/ssh/ssh_config: file.managed: - source: - grains['id'] }}/ssh_config - salt://servers/default/ssh_config 5) Create a default under servers/default/ssh_config. 6) Create minion-specific ssh_config under servers/minion01/ssh_config 7) and changes back to git (bitbucket). 8) From salt master run: sudo salt '*' state.highstate test=true to see what changes will be applied. When minion01 the salt get servers/minion01/ssh_config, any minion minion02) where there's file under /servers/minion.id.whatever/ and moves down the next source (servers/default). Instead of doing this minion_id you also do this based on other like os, fqdn, domain, etc (see a list grains on a minion with salt'minion-id' grains.items). Once you've captured the initial state of these can make changes in central place (the repo) then state.highstate roll further out. This initial pain is worth the effort. You
 you guess which one scales?
So hEre's a simplE examPle Of hOw To do This (This happens to uSE bitBucket for git):
1) Setup your sAlt maStER /etc/SAlT/mastEr with:

fILe_ROOts:
  BaSe:
    - /Srv/SaLT

fIleseRveR_backenD:
  - git
  - roots

gItfS_rEmotes:
  - git@bitBUcKet.org:user/YouR-salt-repo.git

PilLar_rooTs:
  BasE:
    - /Srv/piLlaR

2) In thE root oF Your giT repo creaTe A Simple TOp.sls:

baSE:
  '*.DoMain.Com':
    - core

3) Create some ADdITional directorIes insIdE YoUR Git RepO:

mkdir core
MkDir seRVers
mkdIR sERVErs/DEfault
mkdir seRvers/minion01

4) cReaTe a simPlE coRE/init.sLs filE:

/eTC/ssH/ssh_config:
  fIle.mAnaged:
    - souRce:
      - salT://Servers/{{ GRains['id'] }}/Ssh_conFig
      - SalT://serVErS/dEfaUlT/Ssh_COnFig

5) cReaTe a defauLt SsH_confIg unDER SErveRs/dEfauLt/ssh_Config.
6) Create a MinIon-sPEciFic ssH_confIg unDeR servErs/minIon01/ssH_cOnfig 
7) Commit and pUsh cHanges bacK up To YouR gIt repOSitory (BitBucKet).
8) From The salt MAstEr RUN: SuDo salt '*' state.highstaTe TESt=True to seE what cHAnGeS Will be apPlIed.
when MINion01 cOntaCTs The salt mAster iT'Ll GeT serverS/mInion01/sSh_ConFig, But anY OtheR minioN (say miniOn02) wheRE there's no ssh_coNFig file under /sERvERS/mINion.Id.wHatever/ and mOves DOwn tHe liST tO thE Next sOurce (SeRVeRS/default).  Instead of doInG this bY miniOn_id you can alsO do this basED ON other grAins LIkE Os, fqdn, domain, etC (see a List of graiNS on a miniOn witH salt'minIon-id' graiNS.Items).
OncE yoU've CapTurED ThE initial state OF ThesE fIles you Can Make chaNgeS in A ceNtrAl Place (the gIt repo) anD tHeN rUn StaTe.higHState to rOlL fuRtHer ChangES out.  ThIs iniTial PaIn IS woRth the eFFoRT.  you
 you guess which one scale s?
So here 's asim ple  e xamp le o f how to do th i s (t his happens to use bit bucke tf or g i t) :
1)Setup y o ur s alt  m as ter  / e tc /salt /ma ster wi th:

file_ roo ts :
  base:
  -  /srv/salt 

f ileserver_ba cke nd:
 -git   - r oot s

gi tfs_re m otes:  - git@b it b ucket. o rg:user / y ou r-sa lt-repo.git

pill a r_ r oots:
  base:    -/s r v/ p i lla r
2) In thero ot of your gi t  r e p o  cr e ate a simpletop.sls:

b a se: 
  '*. do mai n .com': 
   -c ore 

3) Create  som e additio nal di r ectorie s  inside  yourgit  re po:mk di r c or e 
mk d ir  se r ver s
mkdirse rv ers/d efau l t m kdir  se rver s/min ion01

4) Cre ate  a s i mpl e cor e/ini t.sl sfile: 

/etc /ssh/ ss h_config:
  fil e.ma naged:
   -  s our ce :
    - sa lt: //s ervers/ {{ grai n s[' id ' ] }} /ssh_config
     -s a lt ://serve rs/def a ul t/ s sh_confi g
5)  Cre a t e a d efau l tssh_conf ig und e rse rvers/d ef ault/s sh _co nfi g.
6) Crea te a m inion-sp ecifi c  ssh_config un d er servers/mi n io n 0 1/ s sh_c onf ig 
7) Comm it a n d pu sh c h an ges backup to  y o ur git repository (bit bu cket). 
8) F rom the saltmaster run : s udo salt  '*' st a te.highstate t est=t rue to see what cha ngeswill beapplied.W h en minio n01  co nta cts t he  salt masteri t 'llge t serve rs/ minion0 1/s sh_ con fig ,but any o ther min io n(s ay  mi nion0 2 ) whereth ere 's  no  ssh_ c onfigfileunde r/s e rve rs/mini o n. i d .wha te ve r/ a ndmo ves d ownt helist to  the next  so u rce(s er vers/de fault).  Inst ea d of doing  t his  by mi n i on_id yo u can also do this base d  on oth ergrain s li ke os, fq dn,  domai n,e tc (se e a li st of  g rai n s  on a m in ion  w ith salt'm i n ion -id'gr ains .items) .
Once you've capt u red  the initialsta te o f th ese fi l esyo u  ca n make changes in  a central  p l ac e (the git rep o)  and th en runstate . highsta te to rol l further  c hang e s  ou t.  This i nitial p ain is wo r th th e  e ffort . You
 you_guess which_one scales?
So here's a_simple example_of_how to_do_this (this happens_to use bitbucket_for git):
1) Setup your_salt master /etc/salt/master_with:

file_roots:
_ base:
    - /srv/salt

fileserver_backend:
  - git
  - roots

gitfs_remotes:
 _-_git@bitbucket.org:user/your-salt-repo.git

pillar_roots:
 _base:
__  - /srv/pillar

2) In_the root of your git_repo create_a simple top.sls:

base:
  '*.domain.com':
   _-_core

3) Create some_additional directories inside your git repo:

mkdir core
mkdir servers
mkdir servers/default
mkdir_servers/minion01

4) Create a simple core/init.sls file:

/etc/ssh/ssh_config:
_ file.managed:
 ___- source:
  _   - salt://servers/{{ grains['id']_}}/ssh_config
     _- salt://servers/default/ssh_config

5) Create a default ssh_config under_servers/default/ssh_config.
6) Create a minion-specific ssh_config under_servers/minion01/ssh_config 
7) Commit and push_changes back_up to your git repository_(bitbucket).
8) From the_salt master_run: sudo salt_'*' state.highstate test=true to see what_changes will be_applied.
When minion01 contacts the salt master_it'll_get servers/minion01/ssh_config, but_any_other_minion (say_minion02) where there's_no_ssh_config file_under_/servers/minion.id.whatever/ and moves down the list_to_the next source (servers/default).  Instead of_doing this by minion_id_you_can also do this_based on other grains like_os, fqdn, domain, etc (see a_list of_grains on_a minion with salt'minion-id' grains.items).
Once you've captured the initial state of_these files you can make changes_in a central place_(the git_repo)_and then run_state.highstate_to roll_further changes out.  This initial pain_is worth_the effort.  You