मैं अपनी खुद की सार्वजनिक कुंजी को Vagrant VM में कैसे जोड़ूँ?

Question 1

मुझे एक Vagrant VM की ssh कुंजी जोड़ने में समस्या हुई। मूल रूप से जो सेटअप मेरे पास है वह ठीक काम करता है। एक बार VMs बन जाने के बाद, मैं उनके माध्यम से उन तक पहुंच बना सकता हूं vagrant ssh, उपयोगकर्ता "योनि" मौजूद है और authorized_keysफ़ाइल में इस उपयोगकर्ता के लिए एक ssh कुंजी है ।

अब मैं क्या करना चाहता हूं: उन वीएम से कनेक्ट sshया उपयोग करने में सक्षम होना scp। इसलिए मुझे केवल अपनी सार्वजनिक कुंजी id_rsa.pubको उसी से जोड़ना होगा authorized_keys- जैसे मैं करूँगा ssh-copy-id।

क्या सेटअप के दौरान वैग्रैंट को यह बताने का कोई तरीका है कि मेरी सार्वजनिक कुंजी को शामिल किया जाना चाहिए? यदि नहीं (जो कि मेरे Google परिणामों के अनुसार संभव है), तो क्या योनि सेटअप के दौरान मेरी सार्वजनिक कुंजी को आसानी से जोड़ने का कोई तरीका है?

Question 2

वांछित सार्वजनिक कुंजी की प्रतिलिपि बनाना प्रावधान चरण में वर्धित रूप से गिर जाएगा । सटीक उत्तर इस बात पर निर्भर करता है कि आप किस प्रावधान का उपयोग करने के लिए कल्पना करते हैं (शेल, शेफ, कठपुतली आदि)। सबसे तुच्छ fileकुंजी के लिए एक संयोजक होगा , कुछ इस तरह से:

config.vm.provision "file", source: "~/.ssh/id_rsa.pub", destination: "~/.ssh/me.pub"

ठीक है, वास्तव में आपको अधिकृत_के लिए अपील करने की आवश्यकता है। शेल उपबंधक का उपयोग करें, जैसे:

config.vm.provision "shell", inline: <<-SHELL
  cat /home/vagrant/.ssh/me.pub >> /home/vagrant/.ssh/authorized_keys
SHELL
end

आप कठपुतली की तरह एक सच्चे प्रावधानक का उपयोग कर सकते हैं । उदाहरण के लिए कठपुतली के साथ SSH अधिकृत कुंजी प्रबंधित करना देखें ।

Question 3

आप रूबी के कोर फ़ाइल मॉड्यूल का उपयोग कर सकते हैं, जैसे:

  config.vm.provision "shell" do |s|
    ssh_pub_key = File.readlines("#{Dir.home}/.ssh/id_rsa.pub").first.strip
    s.inline = <<-SHELL
      echo #{ssh_pub_key} >> /home/vagrant/.ssh/authorized_keys
      echo #{ssh_pub_key} >> /root/.ssh/authorized_keys
    SHELL
  end

यह काम कर रहे उदाहरण संलग्न कर देता है ~/.ssh/id_rsa.pubकरने के लिए ~/.ssh/authorized_keysदोनों आवारा और जड़ उपयोगकर्ता है, जो आप अपने मौजूदा SSH कुंजी का उपयोग करने की अनुमति देगा की।

Question 4

आप जो करना चाहते हैं उसे पूरा करने का एक और "सुरुचिपूर्ण" तरीका है। आप मौजूदा निजी कुंजी पा सकते हैं और अपनी सार्वजनिक कुंजी जोड़ने की परेशानी से गुजरने के बजाय इसका उपयोग कर सकते हैं।

मौजूदा निजी कुंजी का रास्ता देखने के लिए इस तरह आगे बढ़ें ( IdentityFile के लिए नीचे देखें ):

Daud

 योनि ssh-config

परिणाम:

$ योनि ssh-config
मेजबान Magento2.vagrant150
  होस्टनाम 127.0.0.1
  उपयोगकर्ता योनि
  पोर्ट 3150
  UserKnownHostsFile / dev / null
  StrictHostKeyChecking सं
  PasswordAuthentication सं
  IdentityFile "/Users/madismanni/m2/vagrant-magento/.vagrant/machines/magento2.vagrant150/virtualbox/pirt_key"
  पहचानें हाँ
  LogLevel FATAL

फिर आप इस तरह निजी कुंजी का उपयोग कर सकते हैं, पासवर्ड प्रमाणीकरण स्विच करने के लिए स्विच को भी नोट करें

ssh -i /Users/madismanni/m2/vagrant-magento/.vagrant/machines/magento2.vagrant150/virtualbox/pStreet_key -o PasswordAententication = no vagant@127.0.0.1 -p 3150

Question 5

अस्वीकार किए गए सुझाए गए संपादन में यह उत्कृष्ट उत्तर user76329 द्वारा जोड़ा गया था

म्याऊ के उदाहरण पर विस्तार करते हुए , हम स्थानीय पब / निजी ssh कुंजियों को कॉपी कर सकते हैं, अनुमतियाँ सेट कर सकते हैं, और इनलाइन स्क्रिप्ट को निष्क्रिय बना सकते हैं (केवल एक बार चलाता है और केवल दोहराएगा यदि परीक्षण की स्थिति विफल हो जाती है, इस प्रकार प्रावधान की आवश्यकता है):

config.vm.provision "shell" do |s|
  ssh_prv_key = ""
  ssh_pub_key = ""
  if File.file?("#{Dir.home}/.ssh/id_rsa")
    ssh_prv_key = File.read("#{Dir.home}/.ssh/id_rsa")
    ssh_pub_key = File.readlines("#{Dir.home}/.ssh/id_rsa.pub").first.strip
  else
    puts "No SSH key found. You will need to remedy this before pushing to the repository."
  end
  s.inline = <<-SHELL
    if grep -sq "#{ssh_pub_key}" /home/vagrant/.ssh/authorized_keys; then
      echo "SSH keys already provisioned."
      exit 0;
    fi
    echo "SSH key provisioning."
    mkdir -p /home/vagrant/.ssh/
    touch /home/vagrant/.ssh/authorized_keys
    echo #{ssh_pub_key} >> /home/vagrant/.ssh/authorized_keys
    echo #{ssh_pub_key} > /home/vagrant/.ssh/id_rsa.pub
    chmod 644 /home/vagrant/.ssh/id_rsa.pub
    echo "#{ssh_prv_key}" > /home/vagrant/.ssh/id_rsa
    chmod 600 /home/vagrant/.ssh/id_rsa
    chown -R vagrant:vagrant /home/vagrant
    exit 0
  SHELL
end

Question 6

एक छोटा और अधिक सही कोड होना चाहिए:

ssh_pub_key = File.readlines("#{Dir.home}/.ssh/id_rsa.pub").first.strip
config.vm.provision 'shell', inline: 'mkdir -p /root/.ssh'
config.vm.provision 'shell', inline: "echo #{ssh_pub_key} >> /root/.ssh/authorized_keys"
config.vm.provision 'shell', inline: "echo #{ssh_pub_key} >> /home/vagrant/.ssh/authorized_keys", privileged: false

अन्यथा उपयोगकर्ता .ssh/authorized_keysरूट उपयोगकर्ता से संबंधित होगा।

फिर भी यह प्रत्येक प्रावधान पर एक पंक्ति जोड़ देगा, लेकिन परीक्षण के लिए वैग्रंट का उपयोग किया जाता है और एक वीएम में आमतौर पर कम जीवन होता है, इसलिए एक बड़ी समस्या नहीं है।

Question 7

मैं कोड का उपयोग करके समाप्त करता हूं जैसे:

config.ssh.forward_agent    = true
config.ssh.insert_key       = false
config.ssh.private_key_path =  ["~/.vagrant.d/insecure_private_key","~/.ssh/id_rsa"]
config.vm.provision :shell, privileged: false do |s|
  ssh_pub_key = File.readlines("#{Dir.home}/.ssh/id_rsa.pub").first.strip
  s.inline = <<-SHELL
     echo #{ssh_pub_key} >> /home/$USER/.ssh/authorized_keys
     sudo bash -c "echo #{ssh_pub_key} >> /root/.ssh/authorized_keys"
  SHELL
end

ध्यान दें कि उपयोगकर्ता नाम /home/vagrant/.ssh/authorized_keysका उपयोग नहीं करने के बाद से हमें कुछ कोड नहीं करना चाहिए vagrant।

Question 8

पुराने पदों में से किसी ने भी मेरे लिए काम नहीं किया, हालांकि कुछ करीब आए। मुझे टर्मिनल में keygen के साथ rsa कीज़ बनानी थीं और कस्टम कीज़ के साथ जाना था। दूसरे शब्दों में वग्रांत की कुंजियों का उपयोग करने से पराजित किया।

मैं इस पोस्ट की तारीख के रूप में Mac OS Mojave पर हूँ। मैंने एक वैग्रांटफाइल में दो वैग्रैंट बक्से की स्थापना की है। मैं सभी पहले बॉक्स को दिखा रहा हूं ताकि नए संदर्भ संदर्भ देख सकें। मैं .ssh फ़ोल्डर को वैग्रेंट फ़ाइल के समान फ़ोल्डर में रखता हूं, अन्यथा user9091383 सेटअप का उपयोग करें।

इस समाधान का श्रेय इस कोडर को जाता है ।

Vagrant.configure("2") do |config|
  config.vm.define "pfbox", primary: true do |pfbox|
        pfbox.vm.box = "ubuntu/xenial64"
        pfbox.vm.network "forwarded_port", host: 8084, guest: 80
        pfbox.vm.network "forwarded_port", host: 8080, guest: 8080
        pfbox.vm.network "forwarded_port", host: 8079, guest: 8079
        pfbox.vm.network "forwarded_port", host: 3000, guest: 3000
        pfbox.vm.provision :shell, path: ".provision/bootstrap.sh"
        pfbox.vm.synced_folder "ubuntu", "/home/vagrant"
        pfbox.vm.provision "file", source: "~/.gitconfig", destination: "~/.gitconfig"
        pfbox.vm.network "private_network", type: "dhcp"
        pfbox.vm.network "public_network"
        pfbox.ssh.insert_key = false
        ssh_key_path = ".ssh/"  # This may not be necessary.  I may remove.
        pfbox.vm.provision "shell", inline: "mkdir -p /home/vagrant/.ssh"
        pfbox.ssh.private_key_path = ["~/.vagrant.d/insecure_private_key", ".ssh/id_rsa"]
        pfbox.vm.provision "file", source: ".ssh/id_rsa.pub", destination: ".ssh/authorized_keys"
        pfbox.vm.box_check_update = "true"
        pfbox.vm.hostname = "pfbox"
        # VirtualBox
          config.vm.provider "virtualbox" do |vb|
            # vb.gui = true
            vb.name = "pfbox" # friendly name for Oracle VM VirtualBox Manager
            vb.memory = 2048 # memory in megabytes 2.0 GB
            vb.cpus = 1 # cpu cores, can't be more than the host actually has.
          end
  end
  config.vm.define "dbbox" do |dbbox|
        ...

Question 9

यह एक उत्कृष्ट धागा है जिसने मुझे मूल पोस्टर के वर्णन के समान स्थिति को हल करने में मदद की।

हालांकि मैंने अंततः स्मार्टवॉज के उत्तर में प्रस्तुत सेटिंग्स / तर्क का उपयोग किया , मैं एक अड़चन में भाग गया क्योंकि मैं अपने एक विकास प्रणाली पर बाहरी हार्ड ड्राइव पर VAGRANT_HOMEकोर vagrant.dनिर्देशिका सामान को बचाने के लिए पर्यावरण चर का उपयोग करता हूं।

इसलिए यहाँ समायोजित किया गया कोड मैं अपने Vagrantfile में उपयोग कर रहा हूं ताकि एक VAGRANT_HOMEपर्यावरण चर के लिए समायोजित किया जा सके; "जादू" इस पंक्ति में होता है vagrant_home_path = ENV["VAGRANT_HOME"] ||= "~/.vagrant.d":

config.ssh.insert_key = false
config.ssh.forward_agent = true
vagrant_home_path = ENV["VAGRANT_HOME"] ||= "~/.vagrant.d"
config.ssh.private_key_path = ["#{vagrant_home_path}/insecure_private_key", "~/.ssh/id_rsa"]
config.vm.provision :shell, privileged: false do |shell_action|
  ssh_public_key = File.readlines("#{Dir.home}/.ssh/id_rsa.pub").first.strip
  shell_action.inline = <<-SHELL
    echo #{ssh_public_key} >> /home/$USER/.ssh/authorized_keys
  SHELL
end

Question 10

इनलाइन शेल प्रोसीज़र के लिए - सार्वजनिक कुंजी के लिए रिक्त स्थान, टिप्पणियां आदि शामिल हैं, इसलिए सार्वजनिक कुंजी को फैलाने वाले संस्करण के आसपास उद्धरण (बच गए) उद्धरण देना सुनिश्चित करें:

config.vm.provision 'shell', inline: "echo \"#{ssh_pub_key}\" >> /home/vagrant/.ssh/authorized_keys", privileged: false

Question 11

एक सुंदर पूर्ण उदाहरण, आशा है कि यह किसी ऐसे व्यक्ति की मदद करता है जो आगे का दौरा करता है। बाहरी कॉन्‍फ़िगर फ़ाइलों में सभी ठोस मानों को ले जाया गया। आईपी असाइनमेंट सिर्फ कोशिश करने के लिए है।

# -*- mode: ruby -*-
# vi: set ft=ruby :

require 'yaml'
vmconfig = YAML.load_file('vmconfig.yml')

=begin
Script to created VMs with public IPs, VM creation governed by the provided
config file.
All Vagrant configuration is done below. The "2" in Vagrant.configure
configures the configuration version (we support older styles for
backwards compatibility). Please don't change it unless you know what
you're doing
Default user `vagrant` is created and ssh key is overridden. make sure to have
the files `vagrant_rsa` (private key) and `vagrant_rsa.pub` (public key) in the
path `./.ssh/`
Same files need to be available for all the users you want to create in each of
these VMs
=end

uid_start = vmconfig['uid_start']
ip_start = vmconfig['ip_start']
vagrant_private_key = Dir.pwd + '/.ssh/vagrant_rsa'
guest_sshkeys = '/' + Dir.pwd.split('/')[-1] + '/.ssh/'
Vagrant.configure('2') do |config|
  vmconfig['machines'].each do |machine|
    config.vm.define "#{machine}" do |node|
      ip_start += 1
      node.vm.box = vmconfig['vm_box_name']
      node.vm.box_version = vmconfig['vm_box_version']
      node.vm.box_check_update = false
      node.vm.boot_timeout = vmconfig['vm_boot_timeout']
      node.vm.hostname = "#{machine}"
      node.vm.network "public_network", bridge: "#{vmconfig['bridge_name']}", auto_config: false
      node.vm.provision "shell", run: "always", inline: "ifconfig #{vmconfig['ethernet_device']} #{vmconfig['public_ip_part']}#{ip_start} netmask #{vmconfig['subnet_mask']} up"
      node.ssh.insert_key = false
      node.ssh.private_key_path = ['~/.vagrant.d/insecure_private_key', "#{vagrant_private_key}"]
      node.vm.provision "file", source: "#{vagrant_private_key}.pub", destination: "~/.ssh/authorized_keys"
      node.vm.provision "shell", inline: <<-EOC
        sudo sed -i -e "\\#PasswordAuthentication yes# s#PasswordAuthentication yes#PasswordAuthentication no#g" /etc/ssh/sshd_config
        sudo systemctl restart sshd.service
      EOC
      vmconfig['users'].each do |user|
        uid_start += 1
        node.vm.provision "shell", run: "once", privileged: true, inline: <<-CREATEUSER
          sudo useradd -m -s /bin/bash -U #{user} -u #{uid_start}
          sudo mkdir /home/#{user}/.ssh
          sudo cp #{guest_sshkeys}#{user}_rsa.pub /home/#{user}/.ssh/authorized_keys
          sudo chown -R #{user}:#{user} /home/#{user}
          sudo su
          echo "%#{user} ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/#{user}
          exit
        CREATEUSER
      end
    end
  end

Question 12

Madis Maenni उत्तर सबसे अच्छा समाधान के सबसे करीब है:

बस करो:

vagrant ssh-config >> ~/.ssh/config
chmod 600 ~/.ssh/config

तब आप hostname के माध्यम से बस ssh कर सकते हैं।

~ / .Ssh / config में कॉन्फ़िगर किए गए होस्टनामों की सूची प्राप्त करने के लिए

grep -E '^Host ' ~/.ssh/config

मेरा उदाहरण:

$ grep -E '^Host' ~/.ssh/config
Host web
Host db
$ ssh web
[vagrant@web ~]$

Question 13

योनि प्रमाणीकरण के लिए एक आरसा कुंजी जोड़ी उत्पन्न करें ssh-keygen -f ~/.ssh/vagrant

आप अपने लिए आवधिक पहचान फ़ाइलों को भी जोड़ना चाह सकते हैं ~/.ssh/config

IdentityFile ~/.ssh/vagrant
IdentityFile ~/.vagrant.d/insecure_private_key

किसी कारण से हम केवल उस कुंजी को निर्दिष्ट नहीं कर सकते हैं जिसे हम सम्मिलित करना चाहते हैं ताकि हम स्वयं एक कुंजी बनाने के लिए कुछ अतिरिक्त कदम उठाएं। इस तरह हमें सुरक्षा और ज्ञान की जरूरत है कि हमें किस कुंजी की आवश्यकता है (+ सभी आवारा बक्सों को एक ही कुंजी मिलेगी)

असुरक्षित निजी कुंजी का उपयोग करके वीएम को आवारा नहीं कर सकते (योनि 1.7.2) ?

config.ssh.insert_key = false
config.ssh.private_key_path = ['~/.ssh/vagrant', '~/.vagrant.d/insecure_private_key']
config.vm.provision "file", source: "~/.ssh/vagrant.pub", destination: "/home/vagrant/.ssh/vagrant.pub"
config.vm.provision "shell", inline: <<-SHELL
cat /home/vagrant/.ssh/vagrant.pub >> /home/vagrant/.ssh/authorized_keys
mkdir -p /root/.ssh
cat /home/vagrant/.ssh/authorized_keys >> /root/.ssh/authorized_keys

शेल