knife-exec(1) - The man page for the knife exec subcommand.



  • KNIFE-EXEC(1)			  knife exec			 KNIFE-EXEC(1)
    
    
    
    NAME
           knife-exec - The man page for the knife exec subcommand.
    
           The  knife exec subcommand uses the knife configuration file to execute
           Ruby scripts in the context of a  fully	configured  chef-client.  This
           subcommand is most often used to run scripts that will only access Chef
           server one time (or otherwise very infrequently). Use  this  subcommand
           any  time  that	an  operation does not warrant full usage of the knife
           subcommand library.
    
           Authenticated API Requests
    
           The knife exec  subcommand  can	be  used  to  make  authenticated  API
           requests to the Chef server using the following methods:
    
           center;	|l|l|.	 _  T{	Method	T}   T{ Description T} _ T{ api.delete
           T}   T{ Use to delete an object from the Chef server.  T} _ T{  api.get
           T}   T{	Use  to get the details of an object on the Chef server.  T} _
           T{ api.post T}	T{ Use to add an object to the Chef server.  T}  _  T{
           api.put T}   T{ Use to update an object on the Chef server.  T} _
    
           These  methods  are used with the -E option, which executes that string
           locally on the workstation using chef-shell.  These  methods  have  the
           following syntax:
    
    	  $ knife exec -E 'api.method(/endpoint)'
    
           where:
    
           · api.method is the corresponding authentication method --- api.delete,
    	 api.get, api.post, or api.put
    
           · /endpoint is an endpoint in the Chef server API
    
           For example, to get the data for a node named "Example_Node":
    
    	  $ knife exec -E 'puts api.get("/nodes/Example_Node")'
    
           and to ensure that the output is visible in the console, add  the  puts
           in front of the API authorization request:
    
    	  $ knife exec -E 'puts api.get("/nodes/Example_Node")'
    
           where  puts is the shorter version of the $stdout.puts predefined vari‐
           able in Ruby.
    
           The following example shows how to add a client named "IBM305RAMAC" and
           the /clients endpoint, and then return the private key for that user in
           the console:
    
    	  $ client_desc = {
    	      "name"  => "IBM305RAMAC",
    	      "admin" => false
    	    }
    
    	    new_client = api.post("/clients", client_desc)
    	    puts new_client["private_key"]
    
           Syntax
    
           This subcommand has the following syntax:
    
    	  $ knife exec SCRIPT (options)
    
           Options
    
           This subcommand has the following options:
    
           -c CONFIG_FILE, --config CONFIG_FILE
    	      The configuration file to use.
    
           --chef-zero-port PORT
    	      The port on which chef-zero will listen.
    
           --[no-]color
    	      Use to view colored output.
    
           -d, --disable-editing
    	      Use to prevent the $EDITOR from being opened and to accept  data
    	      as-is.
    
           --defaults
    	      Use to have knife use the default value instead of asking a user
    	      to provide one.
    
           -E CODE, --exec CODE
    	      A string of code that will be executed.
    
           -e EDITOR, --editor EDITOR
    	      The $EDITOR that is used for all interactive commands.
    
           --environment ENVIRONMENT
    	      The name of the environment. When this option is added to a com‐
    	      mand, the command will run only against the named environment.
    
           -F FORMAT, --format FORMAT
    	      The output format: summary (default), text, json, yaml, and pp.
    
           -h, --help
    	      Shows help for the command.
    
           -k KEY, --key KEY
    	      The private key that knife will use to sign requests made by the
    	      API client to the Chef server.
    
           -p PATH:PATH, --script-path PATH:PATH
    	      A colon-separated path at which Ruby scripts are located.
    
           --print-after
    	      Use to show data after a destructive operation.
    
           -s URL, --server-url URL
    	      The URL for the Chef server.
    
           -u USER, --user USER
    	      The user name used by knife to sign requests  made  by  the  API
    	      client  to the Chef server. Authentication will fail if the user
    	      name does not match the private key.
    
           -v, --version
    	      The version of the chef-client.
    
           -V, --verbose
    	      Set for more verbose outputs. Use -VV for maximum verbosity.
    
           -y, --yes
    	      Use to respond to all confirmation  prompts  with  "Yes".  knife
    	      will not ask for confirmation.
    
           -z, --local-mode
    	      Use  to  run the chef-client in local mode. This allows all com‐
    	      mands that work against the Chef server to also work against the
    	      local chef-repo.
    
           Examples
    
           There  are  three  ways to use knife exec to run Ruby script files. For
           example:
    
    	  $ knife exec /path/to/script_file
    
           or:
    
    	  $ knife exec -E 'RUBY CODE'
    
           or:
    
    	  $ knife exec
    	  RUBY CODE
    	  ^D
    
           To check the status of knife using a Ruby script named status.rb (which
           looks like):
    
    	  printf "%-5s %-12s %-8s %s\n", "Check In", "Name", "Ruby", "Recipes"
    	  nodes.all do |n|
    	     checkin = Time.at(n['ohai_time']).strftime("%F %R")
    	     rubyver = n['languages']['ruby']['version']
    	     recipes = n.run_list.expand(_default).recipes.join(", ")
    	     printf "%-20s %-12s %-8s %s\n", checkin, n.name, rubyver, recipes
    	  end
    
           and is located in a directory named scripts/, enter:
    
    	  $ knife exec scripts/status.rb
    
           To show the available free memory for all nodes, enter:
    
    	  $ knife exec -E 'nodes.all {|n| puts "#{n.name} has #{n.memory.total} free memory"}'
    
           To list all of the available search indexes, enter:
    
    	  $ knife exec -E 'puts api.get("search").keys'
    
           To  query  a  node  for	multiple  attributes using a Ruby script named
           search_attributes.rb (which looks like):
    
    	  % cat scripts/search_attributes.rb
    	  query = ARGV[2]
    	  attributes = ARGV[3].split(",")
    	  puts "Your query: #{query}"
    	  puts "Your attributes: #{attributes.join(" ")}"
    	  results = {}
    	  search(:node, query) do |n|
    	     results[n.name] = {}
    	     attributes.each {|a| results[n.name][a] = n[a]}
    	  end
    
    	  puts results
    	  exit 0
    
           enter:
    
    	  % knife exec scripts/search_attributes.rb "hostname:test_system" ipaddress,fqdn
    
           to return something like:
    
    	  Your query: hostname:test_system
    	  Your attributes: ipaddress fqdn
    	  {"test_system.example.com"=>{"ipaddress"=>"10.1.1.200", "fqdn"=>"test_system.example.com"}}
    
    AUTHOR
           Chef
    
    
    
    				   Chef 12.0			 KNIFE-EXEC(1)
    

Log in to reply
 

© Lightnetics 2024